@rocketmq/core 0.1.1 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rocketmq/core",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "type": "module",
   "exports": {
     ".": {
@@ -9,10 +9,11 @@
     }
   },
   "dependencies": {
-    "@rocketmq/amqp": "0.1.1",
-    "@rocketmq/serializer": "0.1.1",
-    "@rocketmq/schema": "0.1.1",
-    "@rocketmq/protobuf": "0.1.1"
+    "@rocketmq/amqp": "0.1.2",
+    "@rocketmq/protobuf": "0.1.2",
+    "@rocketmq/schema": "0.1.2",
+    "@rocketmq/zod": "0.1.1",
+    "@rocketmq/serializer": "0.1.2"
   },
   "scripts": {
     "build": "tsup",

package/src/client.test.ts

@@ -10,6 +10,7 @@
 import { Field, Schema, SchemaRegistry } from '@rocketmq/schema';
 import { JsonSerializer } from '@rocketmq/serializer';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { z } from 'zod';
 import { connect, RocketMQ } from './client.js';
 import { ConnectionError, ConsumeError, PublishError, QueueError } from './errors.js';
 
@@ -21,6 +22,7 @@ vi.mock('@rocketmq/amqp', async (importOriginal) => {
     AmqpConnection: {
       connect: vi.fn().mockResolvedValue({
         createChannel: vi.fn().mockResolvedValue({
+          raw: { on: vi.fn(), removeListener: vi.fn() },
           assertQueue: vi.fn().mockResolvedValue({ queue: 'q', messageCount: 0, consumerCount: 0 }),
           close: vi.fn().mockResolvedValue(undefined),
         }),
@@ -31,7 +33,10 @@ vi.mock('@rocketmq/amqp', async (importOriginal) => {
 });
 /** Named fake channel mock. */
 class FakeAmqpChannel {
-  raw = this;
+  raw = {
+    on: vi.fn(),
+    removeListener: vi.fn(),
+  } as unknown as import('@rocketmq/amqp').AmqpChannel['raw'];
   assertQueue = vi.fn().mockResolvedValue({ queue: 'q', messageCount: 0, consumerCount: 0 });
   assertExchange = vi.fn().mockResolvedValue({ exchange: 'ex' });
   bindQueue = vi.fn().mockResolvedValue({});
@@ -66,6 +71,11 @@ describe('RocketMQ', () => {
     expect(mq.channel).toBe(ch);
   });
 
+  it('handles raw channel errors', () => {
+    ch.raw.on.mock.calls[0][1](new Error('broker failure'));
+    expect((mq as any).lastChannelError).toBeInstanceOf(Error);
+  });
+
   describe('assertQueue', () => {
     it('asserts queue without schema', async () => {
       await mq.assertQueue('plain-q');
@@ -124,6 +134,24 @@ describe('RocketMQ', () => {
       );
     });
 
+    it('supports schemaOverride and schemaDelete options', async () => {
+      @Schema()
+      class OverOpt {
+        @Field()
+        id!: string;
+      }
+      new OverOpt();
+
+      await mq.assertQueue('opt-q', OverOpt, {
+        schemaOverride: true,
+        schemaDelete: true,
+      });
+
+      const args = ch.assertQueue.mock.calls[0][1].arguments;
+      expect(args['x-schema-override']).toBe(true);
+      expect(args['x-schema-delete']).toBe(true);
+    });
+
     it('throws QueueError when channel rejects', async () => {
       @Schema()
       class QErr {
@@ -232,11 +260,25 @@ describe('RocketMQ', () => {
     });
   });
 
-  describe('consume (untyped)', () => {
+  describe('consume (typed)', () => {
+    // Stub schema class for consume tests — schema arg is required.
+    class StubMsg {
+      id = '';
+    }
+
     it('subscribes and returns consumer tag', async () => {
       const handler = vi.fn();
-      const tag = await mq.consume('q', handler);
+      const tag = await mq.consume('q', StubMsg, handler, {
+        arguments: { 'x-priority': 10 },
+      });
       expect(tag).toBe('tag-1');
+      expect(ch.consume).toHaveBeenCalledWith(
+        'q',
+        expect.any(Function),
+        expect.objectContaining({
+          arguments: expect.objectContaining({ 'x-priority': 10 }),
+        }),
+      );
     });
 
     it('deserializes and calls handler', async () => {
@@ -245,7 +287,7 @@ describe('RocketMQ', () => {
         cb({ content: Buffer.from('{"a":1}'), fields: {}, properties: {} });
         return { consumerTag: 't' };
       });
-      await mq.consume('q', handler);
+      await mq.consume('q', StubMsg, handler);
       expect(handler).toHaveBeenCalledWith({ a: 1 }, expect.anything());
     });
 
@@ -255,7 +297,7 @@ describe('RocketMQ', () => {
         cb(null);
         return { consumerTag: 't' };
       });
-      await mq.consume('q', handler);
+      await mq.consume('q', StubMsg, handler);
       expect(handler).not.toHaveBeenCalled();
     });
 
@@ -266,7 +308,7 @@ describe('RocketMQ', () => {
         cb({ content: Buffer.from('not-json'), fields: {}, properties: {} });
         return { consumerTag: 't' };
       });
-      await mq.consume('q', handler);
+      await mq.consume('q', StubMsg, handler);
       expect(handler).not.toHaveBeenCalled();
       expect(consoleSpy).toHaveBeenCalled();
       consoleSpy.mockRestore();
@@ -274,7 +316,62 @@ describe('RocketMQ', () => {
 
     it('throws ConsumeError when channel.consume rejects', async () => {
       ch.consume.mockRejectedValue(new Error('NOT_FOUND'));
-      await expect(mq.consume('q', vi.fn())).rejects.toThrow(ConsumeError);
+      await expect(mq.consume('q', StubMsg, vi.fn())).rejects.toThrow(ConsumeError);
+    });
+
+    it('returns empty args when queue not in registry and no schema provided', async () => {
+      const handler = vi.fn();
+      await mq.consume('unregistered-fallback', undefined as never, handler);
+
+      const callArgs = ch.consume.mock.calls[0][2];
+      expect(callArgs.arguments['x-consumer-schema-message']).toBeUndefined();
+    });
+
+    it('falls back to registry when schema is undefined', async () => {
+      // Create a queue with no schema but with a registry entry
+      @Schema()
+      class FallbackMsg {
+        @Field() id!: string;
+      }
+      new FallbackMsg();
+      mq.assertQueue('fallback-q', FallbackMsg);
+
+      // Force consume to use the fallback by casting undefined
+      const handler = vi.fn();
+      await mq.consume('fallback-q', undefined as never, handler);
+
+      const callArgs = ch.consume.mock.calls[0][2];
+      expect(callArgs.arguments['x-consumer-schema-message']).toBe('FallbackMsg');
+    });
+
+    it('returns empty args when fallback registry fails to resolve proto', async () => {
+      // A class without fields fails proto resolution
+      class EmptyFallbackMsg {}
+      registry.register('empty-q', { ctor: EmptyFallbackMsg, name: 'Empty', fields: [] });
+
+      const handler = vi.fn();
+      await mq.consume('empty-q', undefined as never, handler);
+
+      const callArgs = ch.consume.mock.calls[0][2];
+      expect(callArgs.arguments['x-consumer-schema-message']).toBeUndefined();
+    });
+
+    it('returns empty args when resolveConsumerArgs fails', async () => {
+      // Explicit schema without fields fails proto resolution
+      class EmptyMsg {}
+      const handler = vi.fn();
+
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      await mq.consume('err-q', EmptyMsg as never, handler);
+
+      expect(consoleSpy).toHaveBeenCalledWith(
+        expect.stringContaining('failed to build consumer schema for EmptyMsg:'),
+        expect.any(String),
+      );
+      consoleSpy.mockRestore();
+
+      const callArgs = ch.consume.mock.calls[0][2];
+      expect(callArgs.arguments['x-consumer-schema-message']).toBeUndefined();
     });
   });
 
@@ -308,20 +405,166 @@ describe('RocketMQ', () => {
   });
 });
 
+describe('RocketMQ (Zod schemas)', () => {
+  let ch: FakeAmqpChannel;
+  let conn: FakeAmqpConnection;
+  let registry: SchemaRegistry;
+  let mq: RocketMQ;
+
+  beforeEach(() => {
+    ch = new FakeAmqpChannel();
+    conn = new FakeAmqpConnection();
+    registry = new SchemaRegistry();
+    mq = new RocketMQ(conn as never, ch as never, registry, new JsonSerializer());
+  });
+
+  describe('assertQueue with ZodSchemaInput', () => {
+    it('sends proto3 from Zod schema to broker', async () => {
+      const zodInput = {
+        name: 'ZodNotification',
+        schema: z.object({ id: z.string(), content: z.string() }),
+      };
+
+      await mq.assertQueue('zod-q', zodInput);
+
+      expect(ch.assertQueue).toHaveBeenCalledWith(
+        'zod-q',
+        expect.objectContaining({
+          arguments: expect.objectContaining({
+            'x-schema': expect.stringContaining('proto3'),
+            'x-schema-type': 'protobuf',
+            'x-schema-message': 'ZodNotification',
+          }),
+        }),
+      );
+    });
+
+    it('generates correct proto field types from Zod', async () => {
+      const zodInput = {
+        name: 'ZodMixed',
+        schema: z.object({
+          name: z.string(),
+          age: z.number().int(),
+          active: z.boolean(),
+        }),
+      };
+
+      await mq.assertQueue('zod-mixed', zodInput);
+
+      const callArgs = ch.assertQueue.mock.calls[0][1];
+      const proto = callArgs.arguments['x-schema'];
+      expect(proto).toContain('string name = 1;');
+      expect(proto).toContain('int32 age = 2;');
+      expect(proto).toContain('bool active = 3;');
+    });
+
+    it('does not register in decorator registry for Zod schemas', async () => {
+      const zodInput = {
+        name: 'ZodOnly',
+        schema: z.object({ x: z.string() }),
+      };
+
+      await mq.assertQueue('zod-only', zodInput);
+
+      // Zod schemas have no constructor to register
+      expect(registry.lookup('zod-only')).toBeUndefined();
+    });
+
+    it('throws QueueError when channel rejects Zod schema', async () => {
+      const zodInput = {
+        name: 'ZodFail',
+        schema: z.object({ v: z.string() }),
+      };
+
+      ch.assertQueue.mockRejectedValue(new Error('PRECONDITION_FAILED'));
+      await expect(mq.assertQueue('fail-zod', zodInput)).rejects.toThrow(QueueError);
+    });
+  });
+
+  describe('consume with ZodSchemaInput', () => {
+    it('sends consumer schema args from Zod', async () => {
+      const zodInput = {
+        name: 'ZodConsumer',
+        schema: z.object({ id: z.string() }),
+      };
+
+      const handler = vi.fn();
+      await mq.consume('zod-consume', zodInput, handler);
+
+      expect(ch.consume).toHaveBeenCalledWith(
+        'zod-consume',
+        expect.any(Function),
+        expect.objectContaining({
+          arguments: expect.objectContaining({
+            'x-consumer-schema': expect.stringContaining('proto3'),
+            'x-consumer-schema-message': 'ZodConsumer',
+          }),
+        }),
+      );
+    });
+
+    it('subscribes and returns consumer tag with Zod schema', async () => {
+      const zodInput = {
+        name: 'ZodTag',
+        schema: z.object({ id: z.string() }),
+      };
+
+      const handler = vi.fn();
+      const tag = await mq.consume('zod-tag', zodInput, handler);
+      expect(tag).toBe('tag-1');
+    });
+  });
+
+  describe('assertQueue with raw ZodObject', () => {
+    it('derives message name from queue name', async () => {
+      const schema = z.object({ title: z.string() });
+
+      await mq.assertQueue('my-events', schema);
+
+      const callArgs = ch.assertQueue.mock.calls[0][1];
+      expect(callArgs.arguments['x-schema-message']).toBe('MyEvents');
+      expect(callArgs.arguments['x-schema']).toContain('message MyEvents {');
+    });
+  });
+
+  describe('edge cases', () => {
+    it('logs error if consumer schema fails to resolve and has no name', async () => {
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      await mq.consume('q2', {} as any, vi.fn());
+      expect(consoleSpy).toHaveBeenCalled();
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe('consume with raw ZodObject', () => {
+    it('derives consumer message name from queue name', async () => {
+      const schema = z.object({ id: z.string() });
+      const handler = vi.fn();
+
+      await mq.consume('raw-zod-q', schema, handler);
+
+      expect(ch.consume).toHaveBeenCalledWith(
+        'raw-zod-q',
+        expect.any(Function),
+        expect.objectContaining({
+          arguments: expect.objectContaining({
+            'x-consumer-schema-message': 'RawZodQ',
+          }),
+        }),
+      );
+    });
+  });
+});
+
 describe('connect()', () => {
   it('returns a RocketMQ instance on success', async () => {
     const mq = await connect({ url: 'amqp://localhost' });
     expect(mq).toBeInstanceOf(RocketMQ);
   });
 
-  it('uses default URL when none provided', async () => {
-    const mq = await connect();
-    expect(mq).toBeInstanceOf(RocketMQ);
-  });
-
   it('accepts a custom serializer', async () => {
     const custom = new JsonSerializer();
-    const mq = await connect({ serializer: custom });
+    const mq = await connect({ url: 'amqp://localhost', serializer: custom });
     expect(mq).toBeInstanceOf(RocketMQ);
   });