@rocketmq/core 0.1.0

package/.turbo/turbo-build.log

@@ -0,0 +1,21 @@
+
+
+> @rocketmq/core@0.1.0 build /home/edilson/learnspace/rocketmq-broker/rocketmq.js/packages/core
+> tsup
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.1
+CLI Using tsup config: /home/edilson/learnspace/rocketmq-broker/rocketmq.js/packages/core/tsup.config.ts
+CLI Target: es2022
+CLI Cleaning output folder
+ESM Build start
+CJS Build start
+CJS dist/index.cjs 11.01 KB
+CJS ⚡️ Build success in 14ms
+ESM dist/index.js 9.47 KB
+ESM ⚡️ Build success in 15ms
+DTS Build start
+DTS ⚡️ Build success in 521ms
+DTS dist/index.d.ts  6.69 KB
+DTS dist/index.d.cts 6.69 KB

package/dist/index.cjs

@@ -0,0 +1,385 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ConnectionError: () => ConnectionError,
+  ConsumeError: () => ConsumeError,
+  Field: () => import_schema2.Field,
+  PublishError: () => PublishError,
+  QueueError: () => QueueError,
+  QueueHandle: () => QueueHandle,
+  RocketMQ: () => RocketMQ,
+  RocketMQError: () => RocketMQError,
+  Schema: () => import_schema2.Schema,
+  SchemaError: () => SchemaError,
+  SerializationError: () => SerializationError,
+  TimeoutError: () => TimeoutError,
+  connect: () => connect
+});
+module.exports = __toCommonJS(index_exports);
+var import_schema2 = require("@rocketmq/schema");
+
+// src/client.ts
+var import_amqp = require("@rocketmq/amqp");
+var import_protobuf2 = require("@rocketmq/protobuf");
+var import_schema = require("@rocketmq/schema");
+var import_serializer = require("@rocketmq/serializer");
+
+// src/errors.ts
+var RocketMQError = class extends Error {
+  constructor(message, cause) {
+    super(message, { cause });
+    this.name = "RocketMQError";
+  }
+};
+var ConnectionError = class extends RocketMQError {
+  constructor(message, cause) {
+    super(message, cause);
+    this.name = "ConnectionError";
+  }
+};
+var QueueError = class extends RocketMQError {
+  constructor(message, cause) {
+    super(message, cause);
+    this.name = "QueueError";
+  }
+};
+var PublishError = class extends RocketMQError {
+  constructor(queue, cause) {
+    super(`Failed to publish to '${queue}'`, cause);
+    this.queue = queue;
+    this.name = "PublishError";
+  }
+  queue;
+};
+var ConsumeError = class extends RocketMQError {
+  constructor(message, cause) {
+    super(message, cause);
+    this.name = "ConsumeError";
+  }
+};
+var SerializationError = class extends RocketMQError {
+  constructor(message, cause) {
+    super(message, cause);
+    this.name = "SerializationError";
+  }
+};
+var SchemaError = class extends RocketMQError {
+  constructor(message, cause) {
+    super(message, cause);
+    this.name = "SchemaError";
+  }
+};
+var TimeoutError = class extends RocketMQError {
+  constructor(message, cause) {
+    super(message, cause);
+    this.name = "TimeoutError";
+  }
+};
+
+// src/queue-handle.ts
+var import_protobuf = require("@rocketmq/protobuf");
+var QueueHandle = class {
+  constructor(queueName, channel, registry, serializer) {
+    this.queueName = queueName;
+    this.channel = channel;
+    this.registry = registry;
+    this.serializer = serializer;
+  }
+  queueName;
+  channel;
+  registry;
+  serializer;
+  /**
+   * Publishes a typed payload to this queue.
+   *
+   * Pipeline: serialize → send. Validation is broker-side.
+   */
+  send(payload, opts) {
+    try {
+      const buf = this.serializer.serialize(payload);
+      return this.channel.sendToQueue(this.queueName, buf, {
+        contentType: this.serializer.contentType,
+        persistent: true,
+        ...opts
+      });
+    } catch (err) {
+      throw new PublishError(this.queueName, err);
+    }
+  }
+  /**
+   * Subscribes to this queue with typed message handling.
+   *
+   * Sends the consumer's proto definition to the broker via AMQP
+   * arguments so the broker can verify schema subset compatibility.
+   * Malformed messages are logged but not re-thrown to keep the loop alive.
+   */
+  async consume(handler, opts) {
+    const consumerArgs = this.buildConsumerSchemaArgs();
+    try {
+      const reply = await this.channel.consume(
+        this.queueName,
+        (raw) => {
+          if (!raw) return;
+          try {
+            const body = this.serializer.deserialize(raw.content);
+            handler(body, raw);
+          } catch (err) {
+            console.error(`[rocketmq] deserialization error on queue '${this.queueName}':`, err);
+          }
+        },
+        {
+          ...opts,
+          arguments: {
+            ...opts?.arguments,
+            ...consumerArgs
+          }
+        }
+      );
+      return reply.consumerTag;
+    } catch (err) {
+      throw new ConsumeError(`Failed to consume from queue '${this.queueName}'`, err);
+    }
+  }
+  /** Builds AMQP arguments for consumer schema subset checking. */
+  buildConsumerSchemaArgs() {
+    const meta = this.registry.lookup(this.queueName);
+    if (!meta) return {};
+    try {
+      const proto = (0, import_protobuf.toProto)(meta.ctor);
+      return {
+        "x-consumer-schema": proto,
+        "x-consumer-schema-message": meta.name
+      };
+    } catch {
+      return {};
+    }
+  }
+};
+
+// src/client.ts
+async function connect(opts = {}) {
+  const url = opts.url ?? "amqp://guest:guest@localhost:5672";
+  const serializer = opts.serializer ?? new import_serializer.JsonSerializer();
+  try {
+    const conn = await import_amqp.AmqpConnection.connect(url);
+    const ch = await conn.createChannel();
+    return new RocketMQ(conn, ch, import_schema.defaultRegistry, serializer);
+  } catch (err) {
+    throw new ConnectionError(`Failed to connect to ${url}`, err);
+  }
+}
+var RocketMQ = class {
+  constructor(conn, ch, registry, serializer) {
+    this.conn = conn;
+    this.ch = ch;
+    this.registry = registry;
+    this.serializer = serializer;
+  }
+  conn;
+  ch;
+  registry;
+  serializer;
+  /** Exposes the raw AmqpChannel for event listeners (e.g. broker errors). */
+  get channel() {
+    return this.ch;
+  }
+  /**
+   * Creates a typed queue handle bound to a schema class.
+   *
+   * 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.
+   */
+  async queue(name, schema, opts) {
+    await this.assertQueue(name, schema, opts);
+    return new QueueHandle(name, this.ch, this.registry, this.serializer);
+  }
+  /**
+   * Declares a queue with an optional schema class.
+   *
+   * 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.
+   */
+  async assertQueue(name, schema, opts) {
+    if (!schema) {
+      return this.ch.assertQueue(name, opts);
+    }
+    const proto = (0, import_protobuf2.toProto)(schema);
+    const fields = import_schema.defaultRegistry.getFields(schema);
+    const subject = import_schema.defaultRegistry.getSubject(schema);
+    this.registry.register(name, {
+      ctor: schema,
+      name: schema.name,
+      subject,
+      fields: [...fields]
+    });
+    const schemaArgs = {
+      "x-schema": proto,
+      "x-schema-type": "protobuf",
+      "x-schema-message": schema.name
+    };
+    try {
+      return await this.ch.assertQueue(name, {
+        ...opts,
+        arguments: {
+          ...opts?.arguments,
+          ...schemaArgs
+        }
+      });
+    } catch (err) {
+      throw new QueueError(`Failed to assert queue '${name}'`, err);
+    }
+  }
+  /** Declares an exchange (passthrough to AMQP layer). */
+  async assertExchange(name, type, opts) {
+    return this.ch.assertExchange(name, type, opts);
+  }
+  /** Binds a queue to an exchange (passthrough to AMQP layer). */
+  async bindQueue(queue, exchange, routingKey) {
+    return this.ch.bindQueue(queue, exchange, routingKey);
+  }
+  /**
+   * Publishes a JSON message directly to a queue (untyped path).
+   *
+   * Prefer `mq.queue("name", Schema).send()` for type safety.
+   * Validation is handled broker-side via the queue's compiled schema.
+   */
+  sendToQueue(queue, payload, opts) {
+    try {
+      const buf = this.serializer.serialize(payload);
+      return this.ch.sendToQueue(queue, buf, {
+        contentType: this.serializer.contentType,
+        persistent: true,
+        ...opts
+      });
+    } catch (err) {
+      throw new PublishError(queue, err);
+    }
+  }
+  /**
+   * Publishes a JSON message to an exchange with a routing key.
+   */
+  publish(exchange, routingKey, payload, opts) {
+    try {
+      const buf = this.serializer.serialize(payload);
+      return this.ch.publish(exchange, routingKey, buf, {
+        contentType: this.serializer.contentType,
+        persistent: true,
+        ...opts
+      });
+    } catch (err) {
+      throw new PublishError(`exchange:${exchange} routingKey:${routingKey}`, err);
+    }
+  }
+  /**
+   * Subscribes to a queue with JSON deserialization.
+   *
+   * 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.
+   *
+   * Usage:
+   *   await mq.assertQueue("orders", Order);
+   *   await mq.consume("orders", (msg) => console.log(msg));
+   */
+  async consume(queue, handler, opts) {
+    const consumerArgs = this.buildConsumerSchemaArgs(queue);
+    try {
+      const reply = await this.ch.consume(
+        queue,
+        (msg) => {
+          if (!msg) return;
+          try {
+            const body = this.serializer.deserialize(msg.content);
+            handler(body, msg);
+          } catch (err) {
+            console.error(`[rocketmq] deserialization error on queue '${queue}':`, err);
+          }
+        },
+        {
+          ...opts,
+          arguments: {
+            ...opts?.arguments,
+            ...consumerArgs
+          }
+        }
+      );
+      return reply.consumerTag;
+    } catch (err) {
+      throw new ConsumeError(`Failed to consume from queue '${queue}'`, err);
+    }
+  }
+  /**
+   * 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.
+   */
+  buildConsumerSchemaArgs(queue) {
+    const meta = this.registry.lookup(queue);
+    if (!meta) return {};
+    try {
+      const proto = (0, import_protobuf2.toProto)(meta.ctor);
+      return {
+        "x-consumer-schema": proto,
+        "x-consumer-schema-message": meta.name
+      };
+    } catch {
+      return {};
+    }
+  }
+  /** Acknowledges a message. */
+  ack(msg) {
+    this.ch.ack(msg);
+  }
+  /** Negative-acknowledges a message. */
+  nack(msg, requeue) {
+    this.ch.nack(msg, requeue);
+  }
+  /** Sets prefetch count on the channel. */
+  async prefetch(count) {
+    await this.ch.prefetch(count);
+  }
+  /** Closes channel and connection. */
+  async close() {
+    await this.ch.close();
+    await this.conn.close();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConnectionError,
+  ConsumeError,
+  Field,
+  PublishError,
+  QueueError,
+  QueueHandle,
+  RocketMQ,
+  RocketMQError,
+  Schema,
+  SchemaError,
+  SerializationError,
+  TimeoutError,
+  connect
+});

package/dist/index.d.cts

@@ -0,0 +1,160 @@
+import { SchemaRegistry } from '@rocketmq/schema';
+export { Field, FieldMeta, ProtoType, Schema, SchemaEntry } from '@rocketmq/schema';
+import { Serializer } from '@rocketmq/serializer';
+export { Serializer } from '@rocketmq/serializer';
+import * as _rocketmq_amqp from '@rocketmq/amqp';
+import { AmqpChannel, PublishOptions, ConsumeMessage, ConsumeOptions, AmqpConnection, AssertQueueOptions, AssertQueueReply, AssertExchangeOptions, AssertExchangeReply, EmptyReply } from '@rocketmq/amqp';
+export { ConsumeMessage } from '@rocketmq/amqp';
+
+/**
+ * Typed queue handle — the core DX innovation.
+ *
+ * Wraps a queue name with its schema and serializer so every send()
+ * and consume() call is type-safe at compile time. Runtime validation
+ * is delegated to the broker's compiled proto schema.
+ *
+ * Usage:
+ *   const orders = mq.queue("orders", Order);
+ *   await orders.send({ id: "1", customerId: "c1", qty: 5 });
+ *   await orders.consume((msg) => console.log(msg.id));
+ */
+
+declare class QueueHandle<T> {
+    private readonly queueName;
+    private readonly channel;
+    private readonly registry;
+    private readonly serializer;
+    constructor(queueName: string, channel: AmqpChannel, registry: SchemaRegistry, serializer: Serializer);
+    /**
+     * Publishes a typed payload to this queue.
+     *
+     * Pipeline: serialize → send. Validation is broker-side.
+     */
+    send(payload: T, opts?: PublishOptions): boolean;
+    /**
+     * Subscribes to this queue with typed message handling.
+     *
+     * Sends the consumer's proto definition to the broker via AMQP
+     * arguments so the broker can verify schema subset compatibility.
+     * Malformed messages are logged but not re-thrown to keep the loop alive.
+     */
+    consume(handler: (msg: T, raw: ConsumeMessage) => void, opts?: ConsumeOptions): Promise<string>;
+    /** Builds AMQP arguments for consumer schema subset checking. */
+    private buildConsumerSchemaArgs;
+}
+
+interface RocketOptions {
+    /** AMQP connection URL. Default: amqp://guest:guest@localhost:5672 */
+    url?: string;
+    /** Custom serializer. Default: JsonSerializer. */
+    serializer?: Serializer;
+}
+/** Opens a connection + channel ready for schema-aware operations. */
+declare function connect(opts?: RocketOptions): Promise<RocketMQ>;
+declare class RocketMQ {
+    private readonly conn;
+    private readonly ch;
+    private readonly registry;
+    private readonly serializer;
+    constructor(conn: AmqpConnection, ch: AmqpChannel, registry: SchemaRegistry, serializer: Serializer);
+    /** Exposes the raw AmqpChannel for event listeners (e.g. broker errors). */
+    get channel(): AmqpChannel;
+    /**
+     * Creates a typed queue handle bound to a schema class.
+     *
+     * 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.
+     */
+    queue<T>(name: string, schema: new (...args: unknown[]) => T, opts?: AssertQueueOptions): Promise<QueueHandle<T>>;
+    /**
+     * Declares a queue with an optional schema class.
+     *
+     * 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.
+     */
+    assertQueue(name: string, schema?: Function, opts?: AssertQueueOptions): Promise<AssertQueueReply>;
+    /** Declares an exchange (passthrough to AMQP layer). */
+    assertExchange(name: string, type: string, opts?: AssertExchangeOptions): Promise<AssertExchangeReply>;
+    /** Binds a queue to an exchange (passthrough to AMQP layer). */
+    bindQueue(queue: string, exchange: string, routingKey: string): Promise<EmptyReply>;
+    /**
+     * Publishes a JSON message directly to a queue (untyped path).
+     *
+     * Prefer `mq.queue("name", Schema).send()` for type safety.
+     * Validation is handled broker-side via the queue's compiled schema.
+     */
+    sendToQueue(queue: string, payload: Record<string, unknown>, opts?: PublishOptions): boolean;
+    /**
+     * Publishes a JSON message to an exchange with a routing key.
+     */
+    publish(exchange: string, routingKey: string, payload: Record<string, unknown>, opts?: PublishOptions): boolean;
+    /**
+     * Subscribes to a queue with JSON deserialization.
+     *
+     * 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.
+     *
+     * Usage:
+     *   await mq.assertQueue("orders", Order);
+     *   await mq.consume("orders", (msg) => console.log(msg));
+     */
+    consume<T = Record<string, unknown>>(queue: string, handler: (msg: T, raw: ConsumeMessage) => void, opts?: _rocketmq_amqp.ConsumeOptions): Promise<string>;
+    /**
+     * 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;
+    /** Acknowledges a message. */
+    ack(msg: ConsumeMessage): void;
+    /** Negative-acknowledges a message. */
+    nack(msg: ConsumeMessage, requeue?: boolean): void;
+    /** Sets prefetch count on the channel. */
+    prefetch(count: number): Promise<void>;
+    /** Closes channel and connection. */
+    close(): Promise<void>;
+}
+
+/**
+ * Error hierarchy for the RocketMQ SDK.
+ *
+ * Every error includes the offending context (queue name, schema name, etc.)
+ * and preserves the original cause via the standard `cause` property.
+ *
+ * Usage:
+ *   try { ... } catch (err) {
+ *     if (err instanceof PublishError) console.error(err.queue);
+ *   }
+ */
+declare class RocketMQError extends Error {
+    constructor(message: string, cause?: unknown);
+}
+declare class ConnectionError extends RocketMQError {
+    constructor(message: string, cause?: unknown);
+}
+declare class QueueError extends RocketMQError {
+    constructor(message: string, cause?: unknown);
+}
+declare class PublishError extends RocketMQError {
+    readonly queue: string;
+    constructor(queue: string, cause?: unknown);
+}
+declare class ConsumeError extends RocketMQError {
+    constructor(message: string, cause?: unknown);
+}
+declare class SerializationError extends RocketMQError {
+    constructor(message: string, cause?: unknown);
+}
+declare class SchemaError extends RocketMQError {
+    constructor(message: string, cause?: unknown);
+}
+declare class TimeoutError extends RocketMQError {
+    constructor(message: string, cause?: unknown);
+}
+
+export { ConnectionError, ConsumeError, PublishError, QueueError, QueueHandle, RocketMQ, RocketMQError, type RocketOptions, SchemaError, SerializationError, TimeoutError, connect };