@rocketmq/core 0.1.2 → 0.1.3

package/src/client.ts

@@ -5,6 +5,10 @@
  * a single user-facing API. Hides all internal wiring behind `connect()`
  * and `mq.queue()`.
  *
+ * Supports two schema input styles:
+ *   - Decorator classes: `mq.assertQueue('q', MyClass)`
+ *   - Zod schemas:       `mq.assertQueue('q', { name: 'Msg', schema: zodObj })`
+ *
  * Usage:
  *   const mq = await connect();
  *   const orders = mq.queue("orders", Order);
@@ -19,25 +23,60 @@ import {
   type AssertQueueOptions,
   type AssertQueueReply,
   type ConsumeMessage,
+  type ConsumeOptions,
   type EmptyReply,
   type PublishOptions,
 } from '@rocketmq/amqp';
-import { toProto } from '@rocketmq/protobuf';
-import { defaultRegistry, type SchemaRegistry } from '@rocketmq/schema';
+import { defaultRegistry, type Constructor, type SchemaRegistry } from '@rocketmq/schema';
 import { JsonSerializer, type Serializer } from '@rocketmq/serializer';
+import { z } from 'zod';
+import { rethrowBrokerOr } from './error-parser.js';
 import { ConnectionError, ConsumeError, PublishError, QueueError } from './errors.js';
 import { QueueHandle } from './queue-handle.js';
+import { isConstructorInput, resolveProto, type SchemaInput } from './schema-resolver.js';
+
+export type TypedConsumeHandler<T> = (msg: T, raw: ConsumeMessage) => void | Promise<void>;
+
+export interface RocketAssertQueueOptions extends AssertQueueOptions {
+  /** Force update an existing queue's schema even if it conflicts. */
+  schemaOverride?: boolean;
+  /** Remove the schema binding from an existing queue. */
+  schemaDelete?: boolean;
+}
+
+export interface RocketConsumeOptions extends ConsumeOptions {
+  /**
+   * Explicit schema class for consumer compatibility validation.
+   *
+   * TypeScript generics are erased at runtime, so `consume<T>` alone
+   * cannot send `T`'s proto to the broker. Pass the class here so the
+   * broker can verify the consumer's expected fields match the queue's
+   * declared schema.
+   *
+   * Example:
+   *   await mq.consume<Order>('orders', handler, { consumerSchema: Order });
+   */
+  consumerSchema?: Constructor;
+}
+
+const NameSchema = z.string().min(1, 'Name cannot be empty').max(255, 'Name too long');
+
+const RocketOptionsSchema = z.object({
+  url: z.string().url('AMQP connection URL must be a valid URL (e.g. amqp://localhost)'),
+  serializer: z.any().optional(),
+});
 
 export interface RocketOptions {
-  /** AMQP connection URL. Default: amqp://guest:guest@localhost:5672 */
-  url?: string;
+  /** AMQP connection URL. */
+  url: string;
   /** Custom serializer. Default: JsonSerializer. */
   serializer?: Serializer;
 }
 
 /** Opens a connection + channel ready for schema-aware operations. */
-export async function connect(opts: RocketOptions = {}): Promise<RocketMQ> {
-  const url = opts.url ?? 'amqp://guest:guest@localhost:5672';
+export async function connect(opts: RocketOptions): Promise<RocketMQ> {
+  const validated = RocketOptionsSchema.parse(opts);
+  const url = validated.url;
   const serializer = opts.serializer ?? new JsonSerializer();
 
   try {
@@ -50,12 +89,24 @@ export async function connect(opts: RocketOptions = {}): Promise<RocketMQ> {
 }
 
 export class RocketMQ {
+  private lastChannelError: Error | null = null;
+  private readonly errorListener = (err: Error): void => {
+    this.lastChannelError = err;
+  };
+
   constructor(
     private readonly conn: AmqpConnection,
     private readonly ch: AmqpChannel,
     private readonly registry: SchemaRegistry,
     private readonly serializer: Serializer,
-  ) {}
+  ) {
+    // amqplib emits an 'error' event on the channel when the broker sends a Channel.Close
+    // (e.g., due to a 406 PRECONDITION_FAILED for schema mismatches). If this event is
+    // unhandled, it will crash the Node process. amqplib also rejects the pending
+    // Promise (like consume or assertQueue), which we catch and format into a typed
+    // SchemaValidationError. So we can safely swallow the raw event here.
+    this.ch.raw.on('error', this.errorListener);
+  }
 
   /** Exposes the raw AmqpChannel for event listeners (e.g. broker errors). */
   get channel(): AmqpChannel {
@@ -68,63 +119,87 @@ export class RocketMQ {
    * Declares the queue with schema metadata in AMQP arguments so the
    * broker compiles and validates messages. Returns a QueueHandle<T>
    * for type-safe send/consume.
+   *
+   * Usage:
+   *   const orders = await mq.queue('orders', OrderClass);
+   *   const orders = await mq.queue('orders', zodSchema);
    */
   async queue<T>(
     name: string,
-    schema: new (...args: unknown[]) => T,
-    opts?: AssertQueueOptions,
+    schema: SchemaInput<T>,
+    opts?: RocketAssertQueueOptions,
   ): Promise<QueueHandle<T>> {
     await this.assertQueue(name, schema, opts);
-    return new QueueHandle<T>(name, this.ch, this.registry, this.serializer);
+    return new QueueHandle<T>(name, this, schema);
   }
 
   /**
-   * Declares a queue with an optional schema class.
+   * Declares a queue with an optional schema (decorator class or Zod).
    *
    * When a schema is provided the proto3 definition is sent as AMQP
    * queue arguments (`x-schema`, `x-schema-type`, `x-schema-message`)
    * so the broker compiles and validates messages inline.
+   *
+   * Usage:
+   *   await mq.assertQueue('orders', OrderClass);
+   *   await mq.assertQueue('orders', { name: 'Order', schema: zodSchema });
+   *   await mq.assertQueue('orders', zodSchema);  // message name derived from queue name
    */
   async assertQueue(
     name: string,
-    schema?: Function,
-    opts?: AssertQueueOptions,
+    schema?: SchemaInput,
+    opts?: RocketAssertQueueOptions,
   ): Promise<AssertQueueReply> {
+    NameSchema.parse(name);
+
     if (!schema) {
       return this.ch.assertQueue(name, opts);
     }
 
-    const proto = toProto(schema);
-    // WHY: decorators write to defaultRegistry, not the instance registry
-    const fields = defaultRegistry.getFields(schema);
-    const subject = defaultRegistry.getSubject(schema);
-
-    this.registry.register(name, {
-      ctor: schema,
-      name: schema.name,
-      subject,
-      fields: [...fields],
-    });
-
-    // Schema metadata sent as queue arguments so the broker compiles
-    // a proto descriptor and validates JSON payloads on publish.
-    const schemaArgs: Record<string, string> = {
-      'x-schema': proto,
-      'x-schema-type': 'protobuf',
-      'x-schema-message': schema.name,
-    };
+    const schemaArgs = this.buildSchemaQueueArgs(name, schema, opts);
 
     try {
       return await this.ch.assertQueue(name, {
         ...opts,
-        arguments: {
-          ...opts?.arguments,
-          ...schemaArgs,
-        },
+        arguments: { ...opts?.arguments, ...schemaArgs },
       });
     } catch (err) {
-      throw new QueueError(`Failed to assert queue '${name}'`, err);
+      const actualErr = this.lastChannelError ?? err;
+      rethrowBrokerOr(actualErr, new QueueError(`Failed to assert queue '${name}'`, actualErr));
+    }
+  }
+
+  private buildSchemaQueueArgs(
+    name: string,
+    schema: SchemaInput,
+    opts?: RocketAssertQueueOptions,
+  ): Record<string, string | boolean> {
+    const resolved = resolveProto(schema, name);
+
+    // WHY: only register decorator classes — Zod schemas have no constructor
+    if (isConstructorInput(schema)) {
+      this.registerConstructorSchema(name, schema);
     }
+
+    const schemaArgs: Record<string, string | boolean> = {
+      'x-schema': resolved.proto,
+      'x-schema-type': 'protobuf',
+      'x-schema-message': resolved.messageName,
+    };
+    if (opts?.schemaOverride) schemaArgs['x-schema-override'] = true;
+    if (opts?.schemaDelete) schemaArgs['x-schema-delete'] = true;
+
+    return schemaArgs;
+  }
+
+  /** Stores decorator class metadata in the registry for consumer lookups. */
+  private registerConstructorSchema(name: string, schema: Constructor): void {
+    this.registry.register(name, {
+      ctor: schema,
+      name: schema.name,
+      subject: defaultRegistry.getSubject(schema),
+      fields: [...defaultRegistry.getFields(schema)],
+    });
   }
 
   /** Declares an exchange (passthrough to AMQP layer). */
@@ -133,11 +208,14 @@ export class RocketMQ {
     type: string,
     opts?: AssertExchangeOptions,
   ): Promise<AssertExchangeReply> {
+    NameSchema.parse(name);
     return this.ch.assertExchange(name, type, opts);
   }
 
   /** Binds a queue to an exchange (passthrough to AMQP layer). */
   async bindQueue(queue: string, exchange: string, routingKey: string): Promise<EmptyReply> {
+    NameSchema.parse(queue);
+    NameSchema.parse(exchange);
     return this.ch.bindQueue(queue, exchange, routingKey);
   }
 
@@ -148,6 +226,7 @@ export class RocketMQ {
    * Validation is handled broker-side via the queue's compiled schema.
    */
   sendToQueue(queue: string, payload: Record<string, unknown>, opts?: PublishOptions): boolean {
+    NameSchema.parse(queue);
     try {
       const buf = this.serializer.serialize(payload);
       return this.ch.sendToQueue(queue, buf, {
@@ -156,7 +235,7 @@ export class RocketMQ {
         ...opts,
       });
     } catch (err) {
-      throw new PublishError(queue, err);
+      throw new PublishError(queue, payload, err);
     }
   }
 
@@ -177,71 +256,105 @@ export class RocketMQ {
         ...opts,
       });
     } catch (err) {
-      throw new PublishError(`exchange:${exchange} routingKey:${routingKey}`, err);
+      throw new PublishError(`exchange:${exchange} routingKey:${routingKey}`, payload, err);
     }
   }
 
   /**
-   * Subscribes to a queue with JSON deserialization.
+   * Subscribes to a queue with JSON deserialization and broker-side
+   * consumer schema validation.
    *
-   * When a schema was registered via `assertQueue(name, Schema)`,
-   * the consumer's proto definition is sent to the broker for subset
-   * checking — the broker rejects consumers expecting fields the
-   * queue's schema doesn't define.
+   * Accepts either a decorator class or a ZodSchemaInput for the schema
+   * parameter. The schema serves two purposes:
+   * - **Compile-time**: TypeScript infers `T`, so `msg` is fully typed.
+   * - **Runtime**: Its proto definition is sent to the broker as AMQP
+   *   arguments so the broker can verify subset compatibility.
    *
    * Usage:
-   *   await mq.assertQueue("orders", Order);
-   *   await mq.consume("orders", (msg) => console.log(msg));
+   *   await mq.consume("orders", Order, (msg) => console.log(msg.id));
+   *   await mq.consume("orders", { name: "Order", schema: zodSchema }, handler);
+   *   await mq.consume("orders", zodSchema, handler);
    */
-  async consume<T = Record<string, unknown>>(
+  async consume<T>(
     queue: string,
-    handler: (msg: T, raw: ConsumeMessage) => void,
-    opts?: import('@rocketmq/amqp').ConsumeOptions,
+    schema: SchemaInput<T>,
+    handler: TypedConsumeHandler<T>,
+    opts?: RocketConsumeOptions,
   ): Promise<string> {
-    // Build consumer schema arguments for broker-side subset validation.
-    const consumerArgs = this.buildConsumerSchemaArgs(queue);
+    NameSchema.parse(queue);
+    const consumerArgs = this.buildConsumerSchemaArgs(schema, queue);
 
     try {
-      const reply = await this.ch.consume(
-        queue,
-        (msg) => {
-          if (!msg) return;
-          try {
-            const body = this.serializer.deserialize(msg.content) as T;
-            handler(body, msg);
-          } catch (err) {
-            console.error(`[rocketmq] deserialization error on queue '${queue}':`, err);
-          }
-        },
-        {
-          ...opts,
-          arguments: {
-            ...opts?.arguments,
-            ...consumerArgs,
-          },
-        },
-      );
+      const reply = await this.ch.consume(queue, this.createConsumeCallback(queue, handler), {
+        noAck: true,
+        ...opts,
+        arguments: { ...opts?.arguments, ...consumerArgs },
+      });
       return reply.consumerTag;
     } catch (err) {
-      throw new ConsumeError(`Failed to consume from queue '${queue}'`, err);
+      const actualErr = this.lastChannelError ?? err;
+      rethrowBrokerOr(
+        actualErr,
+        new ConsumeError(`Failed to consume from queue '${queue}'`, actualErr),
+      );
     }
   }
 
-  /**
-   * Builds AMQP arguments for consumer schema compatibility checking.
-   *
-   * Returns `x-consumer-schema` + `x-consumer-schema-message` if the
-   * queue has a registered schema, otherwise an empty object.
-   */
-  private buildConsumerSchemaArgs(queue: string): Record<string, string> {
+  private createConsumeCallback<T>(
+    queue: string,
+    handler: TypedConsumeHandler<T>,
+  ): (msg: ConsumeMessage | null) => void {
+    return async (msg: ConsumeMessage | null) => {
+      if (!msg) return;
+      try {
+        const body = this.serializer.deserialize(msg.content) as T;
+        await handler(body, msg);
+      } catch (err) {
+        console.error(`[rocketmq] deserialization error on queue '${queue}':`, err);
+      }
+    };
+  }
+
+  private buildConsumerSchemaArgs(
+    schema: SchemaInput | undefined,
+    queue: string,
+  ): Record<string, string> {
+    if (schema) {
+      return this.resolveConsumerArgs(schema, queue);
+    }
+    return this.fallbackConsumerArgs(queue);
+  }
+
+  /** Resolves consumer schema args from an explicit SchemaInput. */
+  private resolveConsumerArgs(schema: SchemaInput, queue: string): Record<string, string> {
+    try {
+      const resolved = resolveProto(schema, queue);
+      return {
+        'x-consumer-schema': resolved.proto,
+        'x-consumer-schema-message': resolved.messageName,
+      };
+    } catch (err) {
+      const name = isConstructorInput(schema)
+        ? (schema as Constructor).name
+        : (schema as { name: string }).name;
+      console.error(
+        `[rocketmq] failed to build consumer schema for ${name}:`,
+        (err as Error).message,
+      );
+      return {};
+    }
+  }
+
+  /** Falls back to registry lookup when no explicit schema is provided. */
+  private fallbackConsumerArgs(queue: string): Record<string, string> {
     const meta = this.registry.lookup(queue);
     if (!meta) return {};
 
     try {
-      const proto = toProto(meta.ctor);
+      const resolved = resolveProto(meta.ctor, queue);
       return {
-        'x-consumer-schema': proto,
-        'x-consumer-schema-message': meta.name,
+        'x-consumer-schema': resolved.proto,
+        'x-consumer-schema-message': resolved.messageName,
       };
     } catch {
       // WHY: ctor may lack @Field() decorators (e.g. untyped consumers)
@@ -266,6 +379,7 @@ export class RocketMQ {
 
   /** Closes channel and connection. */
   async close(): Promise<void> {
+    this.ch.raw.removeListener('error', this.errorListener);
     await this.ch.close();
     await this.conn.close();
   }

package/src/error-codes.ts

@@ -0,0 +1,30 @@
+/**
+ * Machine-readable error codes returned by the broker.
+ *
+ * These mirror the Rust `ErrorCode` enum 1:1. The client uses them
+ * to construct specific exception subclasses and provide programmatic
+ * access to the error category.
+ *
+ * Usage:
+ *   if (parsed.code === BrokerErrorCode.SchemaTypeMismatch) { ... }
+ */
+export enum BrokerErrorCode {
+  /** Consumer/publisher field type doesn't match queue schema. */
+  SchemaTypeMismatch = 'SchemaTypeMismatch',
+  /** Consumer has fields not present in queue schema. */
+  SchemaExtraFields = 'SchemaExtraFields',
+  /** JSON payload is missing required schema fields. */
+  SchemaMissingFields = 'SchemaMissingFields',
+  /** Re-declaration schema conflicts with existing queue schema. */
+  SchemaConflict = 'SchemaConflict',
+  /** Proto compilation failed (syntax error, etc.). */
+  SchemaCompileFailed = 'SchemaCompileFailed',
+  /** Unsupported schema type (not protobuf). */
+  SchemaUnsupportedType = 'SchemaUnsupportedType',
+  /** Schema validation on publish: wrong JSON value types. */
+  ValidationTypeMismatch = 'ValidationTypeMismatch',
+  /** Payload is not valid JSON. */
+  ValidationInvalidJson = 'ValidationInvalidJson',
+  /** Required AMQP argument missing (x-schema-type, x-schema-message). */
+  MissingArgument = 'MissingArgument',
+}

package/src/error-parser.test.ts

@@ -0,0 +1,223 @@
+import { describe, it, expect } from 'vitest';
+import {
+  parseBrokerError,
+  extractReplyText,
+  formatBrokerError,
+  formatBrokerError,
+  protoToTsType,
+  wrapBrokerError,
+  rethrowBrokerOr,
+} from './error-parser.js';
+import { BrokerErrorCode } from './error-codes.js';
+import { SchemaValidationError } from './errors.js';
+
+describe('protoToTsType', () => {
+  it('maps numeric proto types to number', () => {
+    expect(protoToTsType('double')).toBe('number');
+    expect(protoToTsType('float')).toBe('number');
+    expect(protoToTsType('int32')).toBe('number');
+    expect(protoToTsType('int64')).toBe('number');
+    expect(protoToTsType('uint32')).toBe('number');
+    expect(protoToTsType('sint64')).toBe('number');
+    expect(protoToTsType('fixed32')).toBe('number');
+    expect(protoToTsType('sfixed64')).toBe('number');
+  });
+
+  it('maps bool to boolean', () => {
+    expect(protoToTsType('bool')).toBe('boolean');
+  });
+
+  it('maps string to string', () => {
+    expect(protoToTsType('string')).toBe('string');
+  });
+
+  it('maps bytes to Uint8Array', () => {
+    expect(protoToTsType('bytes')).toBe('Uint8Array');
+  });
+
+  it('returns unknown types as-is', () => {
+    expect(protoToTsType('customType')).toBe('customType');
+  });
+});
+
+describe('parseBrokerError', () => {
+  it('parses valid JSON with all fields', () => {
+    const json = JSON.stringify({
+      code: 'SchemaTypeMismatch',
+      queue: 'test-queue',
+      fields: [{ name: 'id', expected: 'double', got: 'string' }],
+    });
+
+    const result = parseBrokerError(json);
+
+    expect(result).not.toBeNull();
+    expect(result!.code).toBe(BrokerErrorCode.SchemaTypeMismatch);
+    expect(result!.queue).toBe('test-queue');
+    expect(result!.fields).toHaveLength(1);
+    expect(result!.fields[0].name).toBe('id');
+    expect(result!.fields[0].expected).toBe('double');
+    expect(result!.fields[0].got).toBe('string');
+  });
+
+  it('returns null for plain AMQP strings', () => {
+    expect(parseBrokerError('PRECONDITION_FAILED - no such queue')).toBeNull();
+  });
+
+  it('returns null for non-JSON starting with {', () => {
+    expect(parseBrokerError('{not valid json')).toBeNull();
+  });
+
+  it('returns null when code is missing', () => {
+    expect(parseBrokerError('{"queue":"q"}')).toBeNull();
+  });
+
+  it('returns null when queue is missing', () => {
+    expect(parseBrokerError('{"code":"SchemaTypeMismatch"}')).toBeNull();
+  });
+
+  it('handles missing fields array gracefully', () => {
+    const json = JSON.stringify({ code: 'SchemaConflict', queue: 'q' });
+    const result = parseBrokerError(json);
+
+    expect(result).not.toBeNull();
+    expect(result!.fields).toEqual([]);
+  });
+
+  it('parses truncated flag', () => {
+    const json = JSON.stringify({
+      code: 'SchemaTypeMismatch',
+      queue: 'q',
+      fields: [{ name: 'a', expected: 'int32', got: 'string' }],
+      truncated: true,
+    });
+
+    const result = parseBrokerError(json);
+    expect(result!.truncated).toBe(true);
+  });
+
+  it('returns null if parsed JSON is not an object', () => {
+    expect(parseBrokerError('true')).toBeNull();
+    expect(parseBrokerError('null')).toBeNull();
+    expect(parseBrokerError('"string"')).toBeNull();
+    expect(parseBrokerError('[]')).toBeNull();
+  });
+});
+
+describe('extractReplyText', () => {
+  it('extracts reply text from amqplib error', () => {
+    const err = new Error(
+      'Channel closed by server: 406 (PRECONDITION-FAILED) with message "{"code":"SchemaTypeMismatch","queue":"q"}"',
+    );
+    const result = extractReplyText(err);
+    expect(result).toBe('{"code":"SchemaTypeMismatch","queue":"q"}');
+  });
+
+  it('returns null for non-Error values', () => {
+    expect(extractReplyText('string')).toBeNull();
+    expect(extractReplyText(42)).toBeNull();
+    expect(extractReplyText(null)).toBeNull();
+  });
+
+  it('returns null for errors without reply text pattern', () => {
+    expect(extractReplyText(new Error('some other error'))).toBeNull();
+  });
+});
+
+describe('formatBrokerError', () => {
+  it('formats error with field details using TS types', () => {
+    const msg = formatBrokerError({
+      code: BrokerErrorCode.SchemaTypeMismatch,
+      queue: 'orders',
+      fields: [
+        { name: 'id', expected: 'double', got: 'string' },
+        { name: 'count', expected: 'int32', got: 'bool' },
+      ],
+      truncated: false,
+    });
+
+    expect(msg).toContain('[SchemaTypeMismatch]');
+    expect(msg).toContain("Queue 'orders'");
+    expect(msg).toContain('id: expected number, got string');
+    expect(msg).toContain('count: expected number, got boolean');
+  });
+
+  it('formats error without fields', () => {
+    const msg = formatBrokerError({
+      code: BrokerErrorCode.SchemaConflict,
+      queue: 'q',
+      fields: [],
+      truncated: false,
+    });
+
+    expect(msg).toBe("[SchemaConflict] Queue 'q'");
+  });
+
+  it('adds truncation notice', () => {
+    const msg = formatBrokerError({
+      code: BrokerErrorCode.SchemaTypeMismatch,
+      queue: 'q',
+      fields: [{ name: 'a', expected: 'int32', got: 'string' }],
+      truncated: true,
+    });
+
+    expect(msg).toContain('(some fields omitted)');
+  });
+});
+
+describe('SchemaValidationError', () => {
+  it('is an instance of Error and SchemaValidationError', () => {
+    const err = new SchemaValidationError(
+      BrokerErrorCode.SchemaTypeMismatch,
+      'test-queue',
+      [{ name: 'id', expected: 'number', got: 'string' }],
+      'test message',
+    );
+
+    expect(err).toBeInstanceOf(Error);
+    expect(err).toBeInstanceOf(SchemaValidationError);
+    expect(err.code).toBe(BrokerErrorCode.SchemaTypeMismatch);
+    expect(err.queue).toBe('test-queue');
+    expect(err.fields).toHaveLength(1);
+    expect(err.name).toBe('SchemaValidationError');
+  });
+
+  it('preserves cause', () => {
+    const cause = new Error('original');
+    const err = new SchemaValidationError('code', 'q', [], 'msg', cause);
+    expect(err.cause).toBe(cause);
+  });
+});
+
+describe('wrapBrokerError', () => {
+  it('returns null if error is missing reply text', () => {
+    expect(wrapBrokerError(new Error('no reply text here'))).toBeNull();
+  });
+
+  it('returns null if reply text is invalid JSON', () => {
+    const err = new Error('with message "not json"');
+    expect(wrapBrokerError(err)).toBeNull();
+  });
+
+  it('returns a SchemaValidationError on valid broker error', () => {
+    const err = new Error(
+      'with message "{"code":"SchemaTypeMismatch","queue":"q","fields":[{"name":"id","expected":"double","got":"string"}]}"',
+    );
+    const result = wrapBrokerError(err);
+    expect(result).toBeInstanceOf(SchemaValidationError);
+    expect(result!.code).toBe(BrokerErrorCode.SchemaTypeMismatch);
+    expect(result!.queue).toBe('q');
+    expect(result!.fields[0].expected).toBe('number');
+  });
+});
+
+describe('rethrowBrokerOr', () => {
+  it('throws SchemaValidationError if present', () => {
+    const err = new Error('with message "{"code":"SchemaTypeMismatch","queue":"q"}"');
+    expect(() => rethrowBrokerOr(err, new Error('fallback'))).toThrow(SchemaValidationError);
+  });
+
+  it('throws fallback error otherwise', () => {
+    const err = new Error('plain error');
+    expect(() => rethrowBrokerOr(err, new Error('fallback'))).toThrow('fallback');
+  });
+});