@rocketmq/schema 0.1.0

package/.turbo/turbo-build.log

@@ -0,0 +1,21 @@
+
+
+> @rocketmq/schema@0.1.0 build /home/edilson/learnspace/rocketmq-broker/client-ts/packages/schema
+> 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/client-ts/packages/schema/tsup.config.ts
+CLI Target: es2022
+CLI Cleaning output folder
+ESM Build start
+CJS Build start
+CJS dist/index.cjs 3.21 KB
+CJS ⚡️ Build success in 10ms
+ESM dist/index.js 2.11 KB
+ESM ⚡️ Build success in 10ms
+DTS Build start
+DTS ⚡️ Build success in 932ms
+DTS dist/index.d.ts  4.01 KB
+DTS dist/index.d.cts 4.01 KB

package/dist/index.cjs

@@ -0,0 +1,105 @@
+"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, {
+  Field: () => Field,
+  Schema: () => Schema,
+  SchemaRegistry: () => SchemaRegistry,
+  defaultRegistry: () => defaultRegistry
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/registry.ts
+var SchemaRegistry = class {
+  /** Queue name → schema entry. */
+  byQueue = /* @__PURE__ */ new Map();
+  /** Class constructor → field metadata (populated by decorators). */
+  fieldStore = /* @__PURE__ */ new Map();
+  /** Class constructor → subject prefix (populated by @Schema("subject")). */
+  subjectStore = /* @__PURE__ */ new Map();
+  /** Binds a queue name to a fully resolved schema entry. */
+  register(queueName, entry) {
+    this.byQueue.set(queueName, entry);
+  }
+  /** Returns the schema entry for a queue, or undefined if unregistered. */
+  lookup(queueName) {
+    return this.byQueue.get(queueName);
+  }
+  /** Returns all registered schema entries. */
+  listAll() {
+    return [...this.byQueue.values()];
+  }
+  /** Stores the subject prefix set by @Schema("subject"). */
+  setSubject(ctor, subject) {
+    this.subjectStore.set(ctor, subject);
+  }
+  /** Returns the subject prefix for a class, if any. */
+  getSubject(ctor) {
+    return this.subjectStore.get(ctor);
+  }
+  /** Returns the mutable field list for a class, creating it if absent. */
+  getOrCreateFields(ctor) {
+    let fields = this.fieldStore.get(ctor);
+    if (!fields) {
+      fields = [];
+      this.fieldStore.set(ctor, fields);
+    }
+    return fields;
+  }
+  /** Returns the field metadata for a class (read-only snapshot). */
+  getFields(ctor) {
+    return this.fieldStore.get(ctor) ?? [];
+  }
+};
+var defaultRegistry = new SchemaRegistry();
+
+// src/decorators.ts
+function Schema(subject) {
+  return function(target, _ctx) {
+    defaultRegistry.getOrCreateFields(target);
+    if (subject) {
+      defaultRegistry.setSubject(target, subject);
+    }
+    return target;
+  };
+}
+function Field(opts) {
+  return function(_value, ctx) {
+    const name = String(ctx.name);
+    ctx.addInitializer(function() {
+      const ctor = this.constructor;
+      const fields = defaultRegistry.getOrCreateFields(ctor);
+      if (fields.some((f) => f.name === name)) return;
+      fields.push({
+        name,
+        protoType: opts?.type ?? "string",
+        number: fields.length + 1
+      });
+    });
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Field,
+  Schema,
+  SchemaRegistry,
+  defaultRegistry
+});

package/dist/index.d.cts

@@ -0,0 +1,109 @@
+/**
+ * Protobuf wire types supported by the schema decorator system.
+ *
+ * Maps 1:1 to proto3 scalar types so the SDK can generate
+ * `.proto` definitions without requiring protobuf knowledge.
+ *
+ * Usage:
+ *   @Field({ type: "int32" }) qty!: number;
+ */
+type ProtoType = 'string' | 'int32' | 'int64' | 'uint32' | 'uint64' | 'float' | 'double' | 'bool' | 'bytes';
+/** Metadata captured by the @Field() decorator for a single class property. */
+interface FieldMeta {
+    /** Property name on the decorated class. */
+    name: string;
+    /** Proto3 scalar type. Defaults to "string" when omitted. */
+    protoType: ProtoType;
+    /** 1-based field number for proto ordering. */
+    number: number;
+}
+/** Collected metadata for a decorated schema class. */
+interface SchemaEntry {
+    /** Class constructor reference. */
+    ctor: Function;
+    /** Human-readable schema name (defaults to class name). */
+    name: string;
+    /** Optional subject prefix for registry-based validation. */
+    subject?: string;
+    /** Ordered field definitions extracted from @Field() decorators. */
+    fields: FieldMeta[];
+}
+
+/**
+ * In-memory schema registry.
+ *
+ * Replaces the module-level Map globals from the original schema.ts.
+ * Injectable via constructor so tests can use isolated instances.
+ *
+ * Usage:
+ *   const registry = new SchemaRegistry();
+ *   registry.register("orders", entry);
+ *   const entry = registry.lookup("orders");
+ */
+
+declare class SchemaRegistry {
+    /** Queue name → schema entry. */
+    private byQueue;
+    /** Class constructor → field metadata (populated by decorators). */
+    private fieldStore;
+    /** Class constructor → subject prefix (populated by @Schema("subject")). */
+    private subjectStore;
+    /** Binds a queue name to a fully resolved schema entry. */
+    register(queueName: string, entry: SchemaEntry): void;
+    /** Returns the schema entry for a queue, or undefined if unregistered. */
+    lookup(queueName: string): SchemaEntry | undefined;
+    /** Returns all registered schema entries. */
+    listAll(): SchemaEntry[];
+    /** Stores the subject prefix set by @Schema("subject"). */
+    setSubject(ctor: Function, subject: string): void;
+    /** Returns the subject prefix for a class, if any. */
+    getSubject(ctor: Function): string | undefined;
+    /** Returns the mutable field list for a class, creating it if absent. */
+    getOrCreateFields(ctor: Function): FieldMeta[];
+    /** Returns the field metadata for a class (read-only snapshot). */
+    getFields(ctor: Function): readonly FieldMeta[];
+}
+/**
+ * Default singleton registry used by decorators.
+ *
+ * Exported so @Schema() and @Field() can register metadata at class
+ * definition time without requiring explicit wiring. The core package
+ * reads from this same instance during publish/consume.
+ */
+declare const defaultRegistry: SchemaRegistry;
+
+/**
+ * TC39 stage 3 decorators for schema definition.
+ *
+ * Collects field names and types from decorated classes into the
+ * default SchemaRegistry so the SDK can generate proto3 definitions
+ * and validate payloads at runtime.
+ *
+ * Usage:
+ *   @Schema("notifications")
+ *   class Notification {
+ *     @Field() id!: string;
+ *     @Field({ type: "int64" }) timestamp!: number;
+ *   }
+ */
+
+/**
+ * Marks a class as a schema definition.
+ *
+ * @param subject - Optional subject prefix for registry-based validation
+ *                  (e.g. "notifications" → "notifications-value").
+ */
+declare function Schema(subject?: string): <T extends new (...args: unknown[]) => object>(target: T, _ctx: ClassDecoratorContext) => T;
+interface FieldOptions {
+    /** Proto3 scalar type. Defaults to "string". */
+    type?: ProtoType;
+}
+/**
+ * Marks a property as a schema field (TC39 stage 3 field decorator).
+ *
+ * Defers registration to `addInitializer` so the class constructor is
+ * fully defined before we read `this.constructor`.
+ */
+declare function Field(opts?: FieldOptions): (_value: undefined, ctx: ClassFieldDecoratorContext) => void;
+
+export { Field, type FieldMeta, type ProtoType, Schema, type SchemaEntry, SchemaRegistry, defaultRegistry };

package/dist/index.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Protobuf wire types supported by the schema decorator system.
+ *
+ * Maps 1:1 to proto3 scalar types so the SDK can generate
+ * `.proto` definitions without requiring protobuf knowledge.
+ *
+ * Usage:
+ *   @Field({ type: "int32" }) qty!: number;
+ */
+type ProtoType = 'string' | 'int32' | 'int64' | 'uint32' | 'uint64' | 'float' | 'double' | 'bool' | 'bytes';
+/** Metadata captured by the @Field() decorator for a single class property. */
+interface FieldMeta {
+    /** Property name on the decorated class. */
+    name: string;
+    /** Proto3 scalar type. Defaults to "string" when omitted. */
+    protoType: ProtoType;
+    /** 1-based field number for proto ordering. */
+    number: number;
+}
+/** Collected metadata for a decorated schema class. */
+interface SchemaEntry {
+    /** Class constructor reference. */
+    ctor: Function;
+    /** Human-readable schema name (defaults to class name). */
+    name: string;
+    /** Optional subject prefix for registry-based validation. */
+    subject?: string;
+    /** Ordered field definitions extracted from @Field() decorators. */
+    fields: FieldMeta[];
+}
+
+/**
+ * In-memory schema registry.
+ *
+ * Replaces the module-level Map globals from the original schema.ts.
+ * Injectable via constructor so tests can use isolated instances.
+ *
+ * Usage:
+ *   const registry = new SchemaRegistry();
+ *   registry.register("orders", entry);
+ *   const entry = registry.lookup("orders");
+ */
+
+declare class SchemaRegistry {
+    /** Queue name → schema entry. */
+    private byQueue;
+    /** Class constructor → field metadata (populated by decorators). */
+    private fieldStore;
+    /** Class constructor → subject prefix (populated by @Schema("subject")). */
+    private subjectStore;
+    /** Binds a queue name to a fully resolved schema entry. */
+    register(queueName: string, entry: SchemaEntry): void;
+    /** Returns the schema entry for a queue, or undefined if unregistered. */
+    lookup(queueName: string): SchemaEntry | undefined;
+    /** Returns all registered schema entries. */
+    listAll(): SchemaEntry[];
+    /** Stores the subject prefix set by @Schema("subject"). */
+    setSubject(ctor: Function, subject: string): void;
+    /** Returns the subject prefix for a class, if any. */
+    getSubject(ctor: Function): string | undefined;
+    /** Returns the mutable field list for a class, creating it if absent. */
+    getOrCreateFields(ctor: Function): FieldMeta[];
+    /** Returns the field metadata for a class (read-only snapshot). */
+    getFields(ctor: Function): readonly FieldMeta[];
+}
+/**
+ * Default singleton registry used by decorators.
+ *
+ * Exported so @Schema() and @Field() can register metadata at class
+ * definition time without requiring explicit wiring. The core package
+ * reads from this same instance during publish/consume.
+ */
+declare const defaultRegistry: SchemaRegistry;
+
+/**
+ * TC39 stage 3 decorators for schema definition.
+ *
+ * Collects field names and types from decorated classes into the
+ * default SchemaRegistry so the SDK can generate proto3 definitions
+ * and validate payloads at runtime.
+ *
+ * Usage:
+ *   @Schema("notifications")
+ *   class Notification {
+ *     @Field() id!: string;
+ *     @Field({ type: "int64" }) timestamp!: number;
+ *   }
+ */
+
+/**
+ * Marks a class as a schema definition.
+ *
+ * @param subject - Optional subject prefix for registry-based validation
+ *                  (e.g. "notifications" → "notifications-value").
+ */
+declare function Schema(subject?: string): <T extends new (...args: unknown[]) => object>(target: T, _ctx: ClassDecoratorContext) => T;
+interface FieldOptions {
+    /** Proto3 scalar type. Defaults to "string". */
+    type?: ProtoType;
+}
+/**
+ * Marks a property as a schema field (TC39 stage 3 field decorator).
+ *
+ * Defers registration to `addInitializer` so the class constructor is
+ * fully defined before we read `this.constructor`.
+ */
+declare function Field(opts?: FieldOptions): (_value: undefined, ctx: ClassFieldDecoratorContext) => void;
+
+export { Field, type FieldMeta, type ProtoType, Schema, type SchemaEntry, SchemaRegistry, defaultRegistry };

package/dist/index.js

@@ -0,0 +1,75 @@
+// src/registry.ts
+var SchemaRegistry = class {
+  /** Queue name → schema entry. */
+  byQueue = /* @__PURE__ */ new Map();
+  /** Class constructor → field metadata (populated by decorators). */
+  fieldStore = /* @__PURE__ */ new Map();
+  /** Class constructor → subject prefix (populated by @Schema("subject")). */
+  subjectStore = /* @__PURE__ */ new Map();
+  /** Binds a queue name to a fully resolved schema entry. */
+  register(queueName, entry) {
+    this.byQueue.set(queueName, entry);
+  }
+  /** Returns the schema entry for a queue, or undefined if unregistered. */
+  lookup(queueName) {
+    return this.byQueue.get(queueName);
+  }
+  /** Returns all registered schema entries. */
+  listAll() {
+    return [...this.byQueue.values()];
+  }
+  /** Stores the subject prefix set by @Schema("subject"). */
+  setSubject(ctor, subject) {
+    this.subjectStore.set(ctor, subject);
+  }
+  /** Returns the subject prefix for a class, if any. */
+  getSubject(ctor) {
+    return this.subjectStore.get(ctor);
+  }
+  /** Returns the mutable field list for a class, creating it if absent. */
+  getOrCreateFields(ctor) {
+    let fields = this.fieldStore.get(ctor);
+    if (!fields) {
+      fields = [];
+      this.fieldStore.set(ctor, fields);
+    }
+    return fields;
+  }
+  /** Returns the field metadata for a class (read-only snapshot). */
+  getFields(ctor) {
+    return this.fieldStore.get(ctor) ?? [];
+  }
+};
+var defaultRegistry = new SchemaRegistry();
+
+// src/decorators.ts
+function Schema(subject) {
+  return function(target, _ctx) {
+    defaultRegistry.getOrCreateFields(target);
+    if (subject) {
+      defaultRegistry.setSubject(target, subject);
+    }
+    return target;
+  };
+}
+function Field(opts) {
+  return function(_value, ctx) {
+    const name = String(ctx.name);
+    ctx.addInitializer(function() {
+      const ctor = this.constructor;
+      const fields = defaultRegistry.getOrCreateFields(ctor);
+      if (fields.some((f) => f.name === name)) return;
+      fields.push({
+        name,
+        protoType: opts?.type ?? "string",
+        number: fields.length + 1
+      });
+    });
+  };
+}
+export {
+  Field,
+  Schema,
+  SchemaRegistry,
+  defaultRegistry
+};

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@rocketmq/schema",
+  "version": "0.1.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run"
+  }
+}

package/src/decorators.test.ts

@@ -0,0 +1,108 @@
+/**
+ * Tests for @Schema() and @Field() decorators.
+ *
+ * Uses the defaultRegistry singleton to verify that decorators
+ * register metadata correctly. Each test uses unique classes to
+ * avoid cross-contamination in the shared singleton.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { Schema, Field } from './decorators.js';
+import { defaultRegistry } from './registry.js';
+
+describe('@Schema() decorator', () => {
+  it('registers field list for a decorated class', () => {
+    @Schema()
+    class Alpha {
+      @Field()
+      id!: string;
+    }
+    // Force field registration via instantiation
+    new Alpha();
+    const fields = defaultRegistry.getFields(Alpha);
+    expect(fields.length).toBeGreaterThanOrEqual(1);
+    expect(fields[0].name).toBe('id');
+  });
+
+  it('stores subject prefix when provided', () => {
+    @Schema('my-subject')
+    class Beta {
+      @Field()
+      name!: string;
+    }
+    new Beta();
+    expect(defaultRegistry.getSubject(Beta)).toBe('my-subject');
+  });
+
+  it('does not set subject when omitted', () => {
+    @Schema()
+    class Gamma {
+      @Field()
+      val!: string;
+    }
+    new Gamma();
+    expect(defaultRegistry.getSubject(Gamma)).toBeUndefined();
+  });
+
+  it('creates field list even with no @Field() decorators', () => {
+    @Schema()
+    class Empty {}
+    // getOrCreateFields was called by @Schema
+    const fields = defaultRegistry.getFields(Empty);
+    expect(fields).toEqual([]);
+  });
+});
+
+describe('@Field() decorator', () => {
+  it("defaults to protoType 'string'", () => {
+    @Schema()
+    class DefaultType {
+      @Field()
+      name!: string;
+    }
+    new DefaultType();
+    const fields = defaultRegistry.getFields(DefaultType);
+    expect(fields[0].protoType).toBe('string');
+  });
+
+  it('respects explicit type option', () => {
+    @Schema()
+    class ExplicitType {
+      @Field({ type: 'int64' })
+      timestamp!: number;
+    }
+    new ExplicitType();
+    const fields = defaultRegistry.getFields(ExplicitType);
+    expect(fields[0].protoType).toBe('int64');
+  });
+
+  it('assigns sequential field numbers', () => {
+    @Schema()
+    class Multi {
+      @Field()
+      a!: string;
+
+      @Field()
+      b!: string;
+
+      @Field()
+      c!: string;
+    }
+    new Multi();
+    const fields = defaultRegistry.getFields(Multi);
+    expect(fields.map((f) => f.number)).toEqual([1, 2, 3]);
+  });
+
+  it('prevents duplicate registrations from multiple instances', () => {
+    @Schema()
+    class NoDup {
+      @Field()
+      id!: string;
+    }
+    new NoDup();
+    new NoDup();
+    new NoDup();
+    const fields = defaultRegistry.getFields(NoDup);
+    expect(fields.filter((f) => f.name === 'id')).toHaveLength(1);
+  });
+});

package/src/decorators.ts

@@ -0,0 +1,69 @@
+/**
+ * TC39 stage 3 decorators for schema definition.
+ *
+ * Collects field names and types from decorated classes into the
+ * default SchemaRegistry so the SDK can generate proto3 definitions
+ * and validate payloads at runtime.
+ *
+ * Usage:
+ *   @Schema("notifications")
+ *   class Notification {
+ *     @Field() id!: string;
+ *     @Field({ type: "int64" }) timestamp!: number;
+ *   }
+ */
+
+import type { ProtoType } from './metadata.js';
+import { defaultRegistry } from './registry.js';
+
+/**
+ * Marks a class as a schema definition.
+ *
+ * @param subject - Optional subject prefix for registry-based validation
+ *                  (e.g. "notifications" → "notifications-value").
+ */
+export function Schema(subject?: string) {
+  return function <T extends new (...args: unknown[]) => object>(
+    target: T,
+    _ctx: ClassDecoratorContext,
+  ): T {
+    // Ensure the field list exists even if no @Field() was used
+    defaultRegistry.getOrCreateFields(target);
+
+    if (subject) {
+      defaultRegistry.setSubject(target, subject);
+    }
+    return target;
+  };
+}
+
+interface FieldOptions {
+  /** Proto3 scalar type. Defaults to "string". */
+  type?: ProtoType;
+}
+
+/**
+ * Marks a property as a schema field (TC39 stage 3 field decorator).
+ *
+ * Defers registration to `addInitializer` so the class constructor is
+ * fully defined before we read `this.constructor`.
+ */
+export function Field(opts?: FieldOptions) {
+  return function (_value: undefined, ctx: ClassFieldDecoratorContext) {
+    const name = String(ctx.name);
+
+    ctx.addInitializer(function (this: unknown) {
+      const ctor = (this as Record<string, unknown>).constructor as Function;
+      const fields = defaultRegistry.getOrCreateFields(ctor);
+
+      // Prevent duplicate registrations from multiple instantiations
+      if (fields.some((f) => f.name === name)) return;
+
+      fields.push({
+        name,
+        protoType: opts?.type ?? 'string',
+        number: fields.length + 1,
+      });
+    });
+  };
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export type { ProtoType, FieldMeta, SchemaEntry } from './metadata.js';
+export { SchemaRegistry, defaultRegistry } from './registry.js';
+export { Schema, Field } from './decorators.js';

package/src/metadata.test.ts

@@ -0,0 +1,58 @@
+/**
+ * Tests for schema metadata types.
+ *
+ * Verifies that the type definitions compile correctly and that
+ * SchemaEntry can be constructed with all required fields.
+ */
+
+import { describe, it, expect } from 'vitest';
+import type { ProtoType, FieldMeta, SchemaEntry } from './metadata.js';
+
+describe('metadata types', () => {
+  it('accepts all valid ProtoType values', () => {
+    const types: ProtoType[] = [
+      'string',
+      'int32',
+      'int64',
+      'uint32',
+      'uint64',
+      'float',
+      'double',
+      'bool',
+      'bytes',
+    ];
+    expect(types).toHaveLength(9);
+  });
+
+  it('constructs FieldMeta with required properties', () => {
+    const field: FieldMeta = { name: 'id', protoType: 'string', number: 1 };
+    expect(field.name).toBe('id');
+    expect(field.protoType).toBe('string');
+    expect(field.number).toBe(1);
+  });
+
+  it('constructs SchemaEntry with all properties', () => {
+    class Stub {}
+    const entry: SchemaEntry = {
+      ctor: Stub,
+      name: 'Stub',
+      subject: 'test-subject',
+      fields: [{ name: 'id', protoType: 'string', number: 1 }],
+    };
+    expect(entry.ctor).toBe(Stub);
+    expect(entry.name).toBe('Stub');
+    expect(entry.subject).toBe('test-subject');
+    expect(entry.fields).toHaveLength(1);
+  });
+
+  it('constructs SchemaEntry without optional subject', () => {
+    class Stub {}
+    const entry: SchemaEntry = {
+      ctor: Stub,
+      name: 'Stub',
+      fields: [],
+    };
+    expect(entry.subject).toBeUndefined();
+    expect(entry.fields).toHaveLength(0);
+  });
+});

package/src/metadata.ts

@@ -0,0 +1,41 @@
+/**
+ * Protobuf wire types supported by the schema decorator system.
+ *
+ * Maps 1:1 to proto3 scalar types so the SDK can generate
+ * `.proto` definitions without requiring protobuf knowledge.
+ *
+ * Usage:
+ *   @Field({ type: "int32" }) qty!: number;
+ */
+export type ProtoType =
+  | 'string'
+  | 'int32'
+  | 'int64'
+  | 'uint32'
+  | 'uint64'
+  | 'float'
+  | 'double'
+  | 'bool'
+  | 'bytes';
+
+/** Metadata captured by the @Field() decorator for a single class property. */
+export interface FieldMeta {
+  /** Property name on the decorated class. */
+  name: string;
+  /** Proto3 scalar type. Defaults to "string" when omitted. */
+  protoType: ProtoType;
+  /** 1-based field number for proto ordering. */
+  number: number;
+}
+
+/** Collected metadata for a decorated schema class. */
+export interface SchemaEntry {
+  /** Class constructor reference. */
+  ctor: Function;
+  /** Human-readable schema name (defaults to class name). */
+  name: string;
+  /** Optional subject prefix for registry-based validation. */
+  subject?: string;
+  /** Ordered field definitions extracted from @Field() decorators. */
+  fields: FieldMeta[];
+}

package/src/registry.test.ts

@@ -0,0 +1,105 @@
+/**
+ * Tests for SchemaRegistry.
+ *
+ * Covers register/lookup, field store CRUD, subject store,
+ * and listAll enumeration.
+ */
+
+import { beforeEach, describe, expect, it } from 'vitest';
+import type { SchemaEntry } from './metadata.js';
+import { SchemaRegistry } from './registry.js';
+
+describe('SchemaRegistry', () => {
+  let registry: SchemaRegistry;
+
+  beforeEach(() => {
+    registry = new SchemaRegistry();
+  });
+
+  describe('register / lookup', () => {
+    it('stores and retrieves a schema entry by queue name', () => {
+      class Order {}
+      const entry: SchemaEntry = {
+        ctor: Order,
+        name: 'Order',
+        fields: [{ name: 'id', protoType: 'string', number: 1 }],
+      };
+      registry.register('orders', entry);
+      expect(registry.lookup('orders')).toBe(entry);
+    });
+
+    it('returns undefined for unregistered queue', () => {
+      expect(registry.lookup('nonexistent')).toBeUndefined();
+    });
+
+    it('overwrites previous entry on re-registration', () => {
+      class V1 {}
+      class V2 {}
+      const entry1: SchemaEntry = { ctor: V1, name: 'V1', fields: [] };
+      const entry2: SchemaEntry = { ctor: V2, name: 'V2', fields: [] };
+      registry.register('q', entry1);
+      registry.register('q', entry2);
+      expect(registry.lookup('q')).toBe(entry2);
+    });
+  });
+
+  describe('listAll', () => {
+    it('returns empty array when nothing registered', () => {
+      expect(registry.listAll()).toEqual([]);
+    });
+
+    it('returns all registered entries', () => {
+      class A {}
+      class B {}
+      const a: SchemaEntry = { ctor: A, name: 'A', fields: [] };
+      const b: SchemaEntry = { ctor: B, name: 'B', fields: [] };
+      registry.register('qa', a);
+      registry.register('qb', b);
+      expect(registry.listAll()).toHaveLength(2);
+      expect(registry.listAll()).toContain(a);
+      expect(registry.listAll()).toContain(b);
+    });
+  });
+
+  describe('subject store', () => {
+    it('stores and retrieves subject prefix', () => {
+      class X {}
+      registry.setSubject(X, 'my-subject');
+      expect(registry.getSubject(X)).toBe('my-subject');
+    });
+
+    it('returns undefined for class without subject', () => {
+      class Y {}
+      expect(registry.getSubject(Y)).toBeUndefined();
+    });
+  });
+
+  describe('field store', () => {
+    it('creates empty field list on first access', () => {
+      class Z {}
+      const fields = registry.getOrCreateFields(Z);
+      expect(fields).toEqual([]);
+    });
+
+    it('returns same array on subsequent calls', () => {
+      class W {}
+      const first = registry.getOrCreateFields(W);
+      first.push({ name: 'x', protoType: 'int32', number: 1 });
+      const second = registry.getOrCreateFields(W);
+      expect(second).toBe(first);
+      expect(second).toHaveLength(1);
+    });
+
+    it('getFields returns empty for unknown class', () => {
+      class Unknown {}
+      expect(registry.getFields(Unknown)).toEqual([]);
+    });
+
+    it('getFields returns registered fields', () => {
+      class F {}
+      const fields = registry.getOrCreateFields(F);
+      fields.push({ name: 'a', protoType: 'string', number: 1 });
+      expect(registry.getFields(F)).toEqual([{ name: 'a', protoType: 'string', number: 1 }]);
+    });
+  });
+});

package/src/registry.ts

@@ -0,0 +1,73 @@
+/**
+ * In-memory schema registry.
+ *
+ * Replaces the module-level Map globals from the original schema.ts.
+ * Injectable via constructor so tests can use isolated instances.
+ *
+ * Usage:
+ *   const registry = new SchemaRegistry();
+ *   registry.register("orders", entry);
+ *   const entry = registry.lookup("orders");
+ */
+
+import type { FieldMeta, SchemaEntry } from './metadata.js';
+
+export class SchemaRegistry {
+  /** Queue name → schema entry. */
+  private byQueue = new Map<string, SchemaEntry>();
+
+  /** Class constructor → field metadata (populated by decorators). */
+  private fieldStore = new Map<Function, FieldMeta[]>();
+
+  /** Class constructor → subject prefix (populated by @Schema("subject")). */
+  private subjectStore = new Map<Function, string>();
+
+  /** Binds a queue name to a fully resolved schema entry. */
+  register(queueName: string, entry: SchemaEntry): void {
+    this.byQueue.set(queueName, entry);
+  }
+
+  /** Returns the schema entry for a queue, or undefined if unregistered. */
+  lookup(queueName: string): SchemaEntry | undefined {
+    return this.byQueue.get(queueName);
+  }
+
+  /** Returns all registered schema entries. */
+  listAll(): SchemaEntry[] {
+    return [...this.byQueue.values()];
+  }
+
+  /** Stores the subject prefix set by @Schema("subject"). */
+  setSubject(ctor: Function, subject: string): void {
+    this.subjectStore.set(ctor, subject);
+  }
+
+  /** Returns the subject prefix for a class, if any. */
+  getSubject(ctor: Function): string | undefined {
+    return this.subjectStore.get(ctor);
+  }
+
+  /** Returns the mutable field list for a class, creating it if absent. */
+  getOrCreateFields(ctor: Function): FieldMeta[] {
+    let fields = this.fieldStore.get(ctor);
+    if (!fields) {
+      fields = [];
+      this.fieldStore.set(ctor, fields);
+    }
+    return fields;
+  }
+
+  /** Returns the field metadata for a class (read-only snapshot). */
+  getFields(ctor: Function): readonly FieldMeta[] {
+    return this.fieldStore.get(ctor) ?? [];
+  }
+}
+
+/**
+ * Default singleton registry used by decorators.
+ *
+ * Exported so @Schema() and @Field() can register metadata at class
+ * definition time without requiring explicit wiring. The core package
+ * reads from this same instance during publish/consume.
+ */
+export const defaultRegistry = new SchemaRegistry();

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"]
+}

package/tsup.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: ["src/index.ts"],
+  format: ["esm", "cjs"],
+  dts: true,
+  clean: true,
+});