@rocketmq/core 0.1.1 → 0.1.3

package/src/schema-resolver.test.ts

@@ -0,0 +1,112 @@
+/**
+ * Tests for schema-resolver — tri-input proto3 resolution.
+ *
+ * Verifies that resolveProto handles Constructor (decorator), ZodSchemaInput
+ * (wrapper), and raw ZodObject paths. Also tests queueNameToMessageName and
+ * isConstructorInput discrimination.
+ */
+
+import { describe, expect, it } from 'vitest';
+import { z } from 'zod';
+import { Schema, Field } from '@rocketmq/schema';
+import {
+  resolveProto,
+  isConstructorInput,
+  queueNameToMessageName,
+  type SchemaInput,
+} from './schema-resolver.js';
+
+describe('resolveProto', () => {
+  it('resolves a decorator class to proto3', () => {
+    @Schema()
+    class ResolverTest {
+      @Field()
+      id!: string;
+    }
+    new ResolverTest();
+
+    const result = resolveProto(ResolverTest, 'test-q');
+    expect(result.messageName).toBe('ResolverTest');
+    expect(result.proto).toContain('syntax = "proto3"');
+    expect(result.proto).toContain('message ResolverTest {');
+    expect(result.proto).toContain('string id = 1;');
+  });
+
+  it('resolves a ZodSchemaInput wrapper to proto3', () => {
+    const zodInput = {
+      name: 'ZodOrder',
+      schema: z.object({
+        id: z.string(),
+        qty: z.number().int(),
+      }),
+    };
+
+    const result = resolveProto(zodInput, 'orders');
+    expect(result.messageName).toBe('ZodOrder');
+    expect(result.proto).toContain('message ZodOrder {');
+    expect(result.proto).toContain('string id = 1;');
+    expect(result.proto).toContain('int32 qty = 2;');
+  });
+
+  it('resolves a raw ZodObject using queue name as message name', () => {
+    const schema = z.object({
+      title: z.string(),
+      count: z.number().int(),
+    });
+
+    const result = resolveProto(schema, 'my-events');
+    expect(result.messageName).toBe('MyEvents');
+    expect(result.proto).toContain('message MyEvents {');
+    expect(result.proto).toContain('string title = 1;');
+    expect(result.proto).toContain('int32 count = 2;');
+  });
+
+  it('produces different proto for different Zod schemas', () => {
+    const input1 = { name: 'A', schema: z.object({ x: z.string() }) };
+    const input2 = { name: 'B', schema: z.object({ y: z.number() }) };
+
+    expect(resolveProto(input1, 'q').proto).not.toBe(resolveProto(input2, 'q').proto);
+  });
+});
+
+describe('queueNameToMessageName', () => {
+  it('converts kebab-case to PascalCase', () => {
+    expect(queueNameToMessageName('my-queue')).toBe('MyQueue');
+  });
+
+  it('converts snake_case to PascalCase', () => {
+    expect(queueNameToMessageName('order_items')).toBe('OrderItems');
+  });
+
+  it('converts dot-separated to PascalCase', () => {
+    expect(queueNameToMessageName('user.events')).toBe('UserEvents');
+  });
+
+  it('handles single word', () => {
+    expect(queueNameToMessageName('orders')).toBe('Orders');
+  });
+
+  it('handles already PascalCase', () => {
+    expect(queueNameToMessageName('Orders')).toBe('Orders');
+  });
+});
+
+describe('isConstructorInput', () => {
+  it('returns true for a class constructor', () => {
+    class MyClass {}
+    expect(isConstructorInput(MyClass as SchemaInput)).toBe(true);
+  });
+
+  it('returns false for a ZodSchemaInput wrapper', () => {
+    const zodInput = {
+      name: 'Test',
+      schema: z.object({ id: z.string() }),
+    };
+    expect(isConstructorInput(zodInput as SchemaInput)).toBe(false);
+  });
+
+  it('returns false for a raw ZodObject', () => {
+    const raw = z.object({ id: z.string() });
+    expect(isConstructorInput(raw as SchemaInput)).toBe(false);
+  });
+});

package/src/schema-resolver.ts

@@ -0,0 +1,99 @@
+/**
+ * Resolves proto3 definitions from decorator classes, Zod wrappers, or raw ZodObjects.
+ *
+ * Centralizes the tri-input logic so client.ts and queue-handle.ts stay
+ * clean — they just call `resolveProto(input, queueName)` without caring
+ * which path produced it.
+ *
+ * Usage:
+ *   resolveProto(NotificationClass, 'q');
+ *   resolveProto({ name: 'Notif', schema: zodSchema }, 'q');
+ *   resolveProto(zodSchema, 'q');  // message name derived from queue name
+ */
+
+import { toProto } from '@rocketmq/protobuf';
+import type { Constructor } from '@rocketmq/schema';
+import { isRawZodObject, isZodSchemaInput, zodToProto, type ZodSchemaInput } from '@rocketmq/zod';
+import { z } from 'zod';
+
+/**
+ * Union type accepted by assertQueue/consume as the schema parameter.
+ *
+ * Three shapes:
+ *   - `Constructor<T>` — decorator class
+ *   - `ZodSchemaInput` — `{ name, schema }` wrapper with explicit message name
+ *   - `z.ZodType<T>` — bare Zod schema, message name derived from queue name
+ *
+ * WHY z.ZodType<T> instead of z.ZodObject: ZodObject<ZodRawShape> erases T,
+ * so TS can't infer the message type in consume(). ZodType<T> preserves
+ * the output type. Runtime still validates it's a ZodObject via isRawZodObject.
+ */
+export type SchemaInput<T = unknown> = Constructor<T> | ZodSchemaInput | z.ZodType<T>;
+
+/** Result of resolving a SchemaInput to proto3. */
+export interface ResolvedSchema {
+  /** Full proto3 definition string for AMQP x-schema argument. */
+  proto: string;
+  /** Message name for AMQP x-schema-message argument. */
+  messageName: string;
+}
+
+/**
+ * Converts a kebab/snake queue name to PascalCase for the proto message name.
+ *
+ * WHY: protobuf message names must be PascalCase identifiers.
+ * `zod-notifications` → `ZodNotifications`, `order_items` → `OrderItems`.
+ *
+ * Usage:
+ *   queueNameToMessageName('my-queue') // => 'MyQueue'
+ */
+export function queueNameToMessageName(queueName: string): string {
+  return queueName
+    .split(/[-_.]/)
+    .map((seg) => seg.charAt(0).toUpperCase() + seg.slice(1))
+    .join('');
+}
+
+/**
+ * Produces proto3 + message name from a Constructor, ZodSchemaInput, or raw ZodObject.
+ *
+ * When a raw ZodObject is passed, `fallbackName` is converted to PascalCase
+ * and used as the protobuf message name.
+ *
+ * Usage:
+ *   resolveProto(MyClass, 'orders');
+ *   resolveProto({ name: 'Order', schema: zodObj }, 'orders');
+ *   resolveProto(zodObj, 'orders');  // message name = "Orders"
+ */
+export function resolveProto(input: SchemaInput, fallbackName: string): ResolvedSchema {
+  if (isZodSchemaInput(input)) {
+    return {
+      proto: zodToProto(input.name, input.schema),
+      messageName: input.name,
+    };
+  }
+
+  if (isRawZodObject(input)) {
+    const messageName = queueNameToMessageName(fallbackName);
+    return {
+      proto: zodToProto(messageName, input),
+      messageName,
+    };
+  }
+
+  const ctor = input as Constructor;
+  return {
+    proto: toProto(ctor),
+    messageName: ctor.name,
+  };
+}
+
+/**
+ * Type guard: returns true if the input is a class constructor (not Zod).
+ *
+ * Used by the client to conditionally register decorator metadata
+ * (Zod schemas don't have constructors to register).
+ */
+export function isConstructorInput(input: SchemaInput): input is Constructor {
+  return !isZodSchemaInput(input) && !isRawZodObject(input);
+}

package/tsup.config.ts

@@ -5,4 +5,5 @@ export default defineConfig({
   format: ["esm", "cjs"],
   dts: true,
   clean: true,
+  sourcemap: true,
 });