@hazeljs/pubsub 0.7.7

package/dist/__tests__/pubsub-subscriber.service.test.js

@@ -0,0 +1,300 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pubsub_subscriber_service_1 = require("../pubsub-subscriber.service");
+const pubsub_consumer_decorator_1 = require("../decorators/pubsub-consumer.decorator");
+const pubsub_subscribe_decorator_1 = require("../decorators/pubsub-subscribe.decorator");
+jest.mock('../decorators/pubsub-consumer.decorator', () => ({
+    getPubSubConsumerMetadata: jest.fn(),
+    PUBSUB_CONSUMER_METADATA_KEY: Symbol('pubsub:consumer'),
+}));
+jest.mock('../decorators/pubsub-subscribe.decorator', () => ({
+    getPubSubSubscribeMetadata: jest.fn(),
+    PUBSUB_SUBSCRIBE_METADATA_KEY: Symbol('pubsub:subscribe'),
+}));
+const mockOn = jest.fn();
+const mockRemoveListener = jest.fn();
+const mockExists = jest.fn().mockResolvedValue([true]);
+const mockSubscription = {
+    on: mockOn,
+    removeListener: mockRemoveListener,
+    exists: mockExists,
+};
+const mockCreateSubscription = jest.fn().mockResolvedValue([{}]);
+const mockTopic = jest.fn().mockReturnValue({
+    createSubscription: mockCreateSubscription,
+});
+const mockPubSub = {
+    subscription: jest.fn().mockReturnValue(mockSubscription),
+    topic: mockTopic,
+};
+const mockGetConsumerMetadata = pubsub_consumer_decorator_1.getPubSubConsumerMetadata;
+const mockGetSubscribeMetadata = pubsub_subscribe_decorator_1.getPubSubSubscribeMetadata;
+describe('PubSubSubscriberService', () => {
+    let service;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockExists.mockResolvedValue([true]);
+        service = new pubsub_subscriber_service_1.PubSubSubscriberService(mockPubSub);
+    });
+    it('returns when provider has no @PubSubConsumer metadata', async () => {
+        mockGetConsumerMetadata.mockReturnValue(undefined);
+        mockGetSubscribeMetadata.mockReturnValue([]);
+        class Provider {
+        }
+        await service.registerFromProvider(new Provider());
+        expect(mockPubSub.subscription).not.toHaveBeenCalled();
+    });
+    it('returns when provider has no @PubSubSubscribe metadata', async () => {
+        mockGetConsumerMetadata.mockReturnValue({ ackOnSuccess: true });
+        mockGetSubscribeMetadata.mockReturnValue([]);
+        class Provider {
+        }
+        await service.registerFromProvider(new Provider());
+        expect(mockPubSub.subscription).not.toHaveBeenCalled();
+    });
+    it('registers and wires message handlers', async () => {
+        mockGetConsumerMetadata.mockReturnValue({
+            ackOnSuccess: true,
+            nackOnError: true,
+            parseJson: true,
+        });
+        mockGetSubscribeMetadata.mockReturnValue([
+            { methodName: 'handleMessage', options: { subscription: 'orders-sub' } },
+        ]);
+        class Provider {
+            async handleMessage() { }
+        }
+        await service.registerFromProvider(new Provider());
+        expect(mockPubSub.subscription).toHaveBeenCalledWith('orders-sub');
+        expect(mockOn).toHaveBeenCalledWith('message', expect.any(Function));
+        expect(service.getSubscriptionCount()).toBe(1);
+    });
+    it('skips registration when method does not exist on provider', async () => {
+        mockGetConsumerMetadata.mockReturnValue({ ackOnSuccess: true });
+        mockGetSubscribeMetadata.mockReturnValue([
+            { methodName: 'missingMethod', options: { subscription: 'orders-sub' } },
+        ]);
+        class Provider {
+        }
+        await service.registerFromProvider(new Provider());
+        expect(mockOn).not.toHaveBeenCalled();
+        expect(service.getSubscriptionCount()).toBe(0);
+    });
+    it('acks on successful handler completion by default', async () => {
+        mockGetConsumerMetadata.mockReturnValue({
+            ackOnSuccess: true,
+            nackOnError: true,
+            parseJson: true,
+        });
+        mockGetSubscribeMetadata.mockReturnValue([
+            { methodName: 'handleMessage', options: { subscription: 'orders-sub' } },
+        ]);
+        const handleSpy = jest.fn().mockResolvedValue(undefined);
+        class Provider {
+            async handleMessage(payload) {
+                handleSpy(payload);
+            }
+        }
+        await service.registerFromProvider(new Provider());
+        const messageHandler = mockOn.mock.calls.find((call) => call[0] === 'message')?.[1];
+        const ack = jest.fn();
+        const nack = jest.fn();
+        await messageHandler({
+            data: Buffer.from(JSON.stringify({ id: 1 })),
+            attributes: {},
+            id: 'm-1',
+            ack,
+            nack,
+        });
+        expect(handleSpy).toHaveBeenCalled();
+        expect(ack).toHaveBeenCalledTimes(1);
+        expect(nack).not.toHaveBeenCalled();
+    });
+    it('nacks on handler error when enabled', async () => {
+        mockGetConsumerMetadata.mockReturnValue({
+            ackOnSuccess: true,
+            nackOnError: true,
+            parseJson: true,
+        });
+        mockGetSubscribeMetadata.mockReturnValue([
+            { methodName: 'handleMessage', options: { subscription: 'orders-sub' } },
+        ]);
+        class Provider {
+            async handleMessage() {
+                throw new Error('failed');
+            }
+        }
+        await service.registerFromProvider(new Provider());
+        const messageHandler = mockOn.mock.calls.find((call) => call[0] === 'message')?.[1];
+        const ack = jest.fn();
+        const nack = jest.fn();
+        await messageHandler({
+            data: Buffer.from('test'),
+            attributes: {},
+            id: 'm-2',
+            ack,
+            nack,
+        });
+        expect(ack).not.toHaveBeenCalled();
+        expect(nack).toHaveBeenCalledTimes(1);
+    });
+    it('does not nack on handler error when nackOnError is false', async () => {
+        mockGetConsumerMetadata.mockReturnValue({
+            ackOnSuccess: true,
+            nackOnError: false,
+            parseJson: true,
+        });
+        mockGetSubscribeMetadata.mockReturnValue([
+            { methodName: 'handleMessage', options: { subscription: 'orders-sub' } },
+        ]);
+        class Provider {
+            async handleMessage() {
+                throw new Error('failed');
+            }
+        }
+        await service.registerFromProvider(new Provider());
+        const messageHandler = mockOn.mock.calls.find((call) => call[0] === 'message')?.[1];
+        const ack = jest.fn();
+        const nack = jest.fn();
+        await messageHandler({
+            data: Buffer.from('test'),
+            attributes: {},
+            id: 'm-3',
+            ack,
+            nack,
+        });
+        expect(ack).not.toHaveBeenCalled();
+        expect(nack).not.toHaveBeenCalled();
+    });
+    it('nacks when handler explicitly returns "nack"', async () => {
+        mockGetConsumerMetadata.mockReturnValue({
+            ackOnSuccess: true,
+            nackOnError: true,
+            parseJson: true,
+        });
+        mockGetSubscribeMetadata.mockReturnValue([
+            { methodName: 'handleMessage', options: { subscription: 'orders-sub' } },
+        ]);
+        class Provider {
+            async handleMessage() {
+                return 'nack';
+            }
+        }
+        await service.registerFromProvider(new Provider());
+        const messageHandler = mockOn.mock.calls.find((call) => call[0] === 'message')?.[1];
+        const ack = jest.fn();
+        const nack = jest.fn();
+        await messageHandler({
+            data: Buffer.from('test'),
+            attributes: {},
+            id: 'm-4',
+            ack,
+            nack,
+        });
+        expect(ack).not.toHaveBeenCalled();
+        expect(nack).toHaveBeenCalledTimes(1);
+    });
+    it('passes publish metadata and supports manual ack/nack in payload', async () => {
+        mockGetConsumerMetadata.mockReturnValue({
+            ackOnSuccess: false,
+            nackOnError: true,
+            parseJson: false,
+        });
+        mockGetSubscribeMetadata.mockReturnValue([
+            { methodName: 'handleMessage', options: { subscription: 'orders-sub' } },
+        ]);
+        const capturedPayloads = [];
+        class Provider {
+            async handleMessage(payload) {
+                capturedPayloads.push(payload);
+                payload.ack();
+                payload.nack();
+                return 'ack';
+            }
+        }
+        await service.registerFromProvider(new Provider());
+        const messageHandler = mockOn.mock.calls.find((call) => call[0] === 'message')?.[1];
+        const ack = jest.fn();
+        const nack = jest.fn();
+        await messageHandler({
+            data: Buffer.from('plain text'),
+            attributes: { source: 'test' },
+            id: 'm-5',
+            orderingKey: 'order-123',
+            publishTime: '2026-01-01T00:00:00.000Z',
+            ack,
+            nack,
+        });
+        expect(capturedPayloads).toHaveLength(1);
+        const payload = capturedPayloads[0];
+        expect(payload.data).toBe('plain text');
+        expect(payload.orderingKey).toBe('order-123');
+        expect(payload.publishTime).toBeInstanceOf(Date);
+        expect(ack).toHaveBeenCalled();
+        expect(nack).toHaveBeenCalled();
+    });
+    it('supports auto-creating subscriptions', async () => {
+        mockGetConsumerMetadata.mockReturnValue({ autoCreateSubscription: true });
+        mockGetSubscribeMetadata.mockReturnValue([
+            {
+                methodName: 'handleMessage',
+                options: {
+                    subscription: 'new-subscription',
+                    topic: 'orders',
+                    autoCreateSubscription: true,
+                },
+            },
+        ]);
+        mockExists.mockResolvedValue([false]);
+        class Provider {
+            async handleMessage() { }
+        }
+        await service.registerFromProvider(new Provider());
+        expect(mockCreateSubscription).toHaveBeenCalledWith('new-subscription');
+    });
+    it('throws when auto-create is enabled without topic', async () => {
+        mockGetConsumerMetadata.mockReturnValue({ autoCreateSubscription: true });
+        mockGetSubscribeMetadata.mockReturnValue([
+            {
+                methodName: 'handleMessage',
+                options: {
+                    subscription: 'new-subscription',
+                    autoCreateSubscription: true,
+                },
+            },
+        ]);
+        mockExists.mockResolvedValue([false]);
+        class Provider {
+            async handleMessage() { }
+        }
+        await expect(service.registerFromProvider(new Provider())).rejects.toThrow(/without a topic/i);
+    });
+    it('cleans up listeners on destroy', async () => {
+        mockGetConsumerMetadata.mockReturnValue({ ackOnSuccess: true });
+        mockGetSubscribeMetadata.mockReturnValue([
+            { methodName: 'handleMessage', options: { subscription: 'orders-sub' } },
+        ]);
+        class Provider {
+            async handleMessage() { }
+        }
+        await service.registerFromProvider(new Provider());
+        await service.onModuleDestroy();
+        expect(mockRemoveListener).toHaveBeenCalledWith('message', expect.any(Function));
+        expect(service.getSubscriptionCount()).toBe(0);
+    });
+    it('handles removeListener errors during destroy', async () => {
+        mockGetConsumerMetadata.mockReturnValue({ ackOnSuccess: true });
+        mockGetSubscribeMetadata.mockReturnValue([
+            { methodName: 'handleMessage', options: { subscription: 'orders-sub' } },
+        ]);
+        class Provider {
+            async handleMessage() { }
+        }
+        await service.registerFromProvider(new Provider());
+        mockRemoveListener.mockImplementationOnce(() => {
+            throw new Error('remove failed');
+        });
+        await expect(service.onModuleDestroy()).resolves.toBeUndefined();
+        expect(service.getSubscriptionCount()).toBe(0);
+    });
+});

package/dist/__tests__/pubsub.decorator.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=pubsub.decorator.test.d.ts.map

package/dist/__tests__/pubsub.decorator.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pubsub.decorator.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/pubsub.decorator.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/pubsub.decorator.test.js

@@ -0,0 +1,90 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pubsub_consumer_decorator_1 = require("../decorators/pubsub-consumer.decorator");
+const pubsub_subscribe_decorator_1 = require("../decorators/pubsub-subscribe.decorator");
+describe('PubSubConsumer decorator', () => {
+    it('sets default consumer metadata', () => {
+        let TestConsumer = class TestConsumer {
+        };
+        TestConsumer = __decorate([
+            (0, pubsub_consumer_decorator_1.PubSubConsumer)()
+        ], TestConsumer);
+        const metadata = (0, pubsub_consumer_decorator_1.getPubSubConsumerMetadata)(TestConsumer.prototype);
+        expect(metadata).toBeDefined();
+        expect(metadata?.ackOnSuccess).toBe(true);
+        expect(metadata?.nackOnError).toBe(true);
+        expect(metadata?.parseJson).toBe(true);
+    });
+    it('sets custom consumer metadata', () => {
+        let CustomConsumer = class CustomConsumer {
+        };
+        CustomConsumer = __decorate([
+            (0, pubsub_consumer_decorator_1.PubSubConsumer)({ ackOnSuccess: false, parseJson: false })
+        ], CustomConsumer);
+        const metadata = (0, pubsub_consumer_decorator_1.getPubSubConsumerMetadata)(CustomConsumer.prototype);
+        expect(metadata?.ackOnSuccess).toBe(false);
+        expect(metadata?.parseJson).toBe(false);
+    });
+    it('identifies pubsub consumer classes', () => {
+        let ConsumerClass = class ConsumerClass {
+        };
+        ConsumerClass = __decorate([
+            (0, pubsub_consumer_decorator_1.PubSubConsumer)()
+        ], ConsumerClass);
+        expect((0, pubsub_consumer_decorator_1.isPubSubConsumer)(ConsumerClass.prototype)).toBe(true);
+    });
+    it('returns false for non-consumer classes', () => {
+        class RegularClass {
+        }
+        expect((0, pubsub_consumer_decorator_1.isPubSubConsumer)(RegularClass.prototype)).toBe(false);
+    });
+});
+describe('PubSubSubscribe decorator', () => {
+    it('stores subscription metadata on method', () => {
+        class TestConsumer {
+            handleOrders() { }
+        }
+        __decorate([
+            (0, pubsub_subscribe_decorator_1.PubSubSubscribe)({ subscription: 'orders-sub' }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], TestConsumer.prototype, "handleOrders", null);
+        const metadata = (0, pubsub_subscribe_decorator_1.getPubSubSubscribeMetadata)(TestConsumer.prototype);
+        expect(metadata).toHaveLength(1);
+        expect(metadata[0].methodName).toBe('handleOrders');
+        expect(metadata[0].options.subscription).toBe('orders-sub');
+    });
+    it('supports multiple subscription handlers', () => {
+        class MultiConsumer {
+            handleA() { }
+            handleB() { }
+        }
+        __decorate([
+            (0, pubsub_subscribe_decorator_1.PubSubSubscribe)({ subscription: 'sub-a' }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], MultiConsumer.prototype, "handleA", null);
+        __decorate([
+            (0, pubsub_subscribe_decorator_1.PubSubSubscribe)({ subscription: 'sub-b', parseJson: false }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], MultiConsumer.prototype, "handleB", null);
+        const metadata = (0, pubsub_subscribe_decorator_1.getPubSubSubscribeMetadata)(MultiConsumer.prototype);
+        expect(metadata).toHaveLength(2);
+        expect(metadata[0].options.subscription).toBe('sub-a');
+        expect(metadata[1].options.subscription).toBe('sub-b');
+        expect(metadata[1].options.parseJson).toBe(false);
+    });
+});

package/dist/__tests__/pubsub.module.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=pubsub.module.test.d.ts.map

package/dist/__tests__/pubsub.module.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pubsub.module.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/pubsub.module.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/pubsub.module.test.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@hazeljs/core");
+const pubsub_module_1 = require("../pubsub.module");
+const pubsub_publisher_service_1 = require("../pubsub-publisher.service");
+describe('PubSubModule', () => {
+    describe('forRoot', () => {
+        it('returns PubSubModule and registers client', () => {
+            const result = pubsub_module_1.PubSubModule.forRoot({
+                projectId: 'test-project',
+            });
+            expect(result).toBe(pubsub_module_1.PubSubModule);
+            const container = core_1.Container.getInstance();
+            const client = container.resolve(pubsub_publisher_service_1.PUBSUB_CLIENT_TOKEN);
+            expect(client).toBeDefined();
+            expect(client?.topic).toBeDefined();
+        });
+    });
+    describe('forRootAsync', () => {
+        it('returns PubSubModule and registers client', async () => {
+            const result = await pubsub_module_1.PubSubModule.forRootAsync({
+                useFactory: () => Promise.resolve({
+                    projectId: 'async-project',
+                }),
+                inject: [],
+            });
+            expect(result).toBe(pubsub_module_1.PubSubModule);
+            const container = core_1.Container.getInstance();
+            const client = container.resolve(pubsub_publisher_service_1.PUBSUB_CLIENT_TOKEN);
+            expect(client).toBeDefined();
+        });
+    });
+});

package/dist/decorators/pubsub-consumer.decorator.d.ts

@@ -0,0 +1,7 @@
+import 'reflect-metadata';
+import { PubSubConsumerOptions } from '../pubsub.types';
+export declare const PUBSUB_CONSUMER_METADATA_KEY: unique symbol;
+export declare function PubSubConsumer(options?: PubSubConsumerOptions): ClassDecorator;
+export declare function getPubSubConsumerMetadata(target: object): PubSubConsumerOptions | undefined;
+export declare function isPubSubConsumer(target: object): boolean;
+//# sourceMappingURL=pubsub-consumer.decorator.d.ts.map

package/dist/decorators/pubsub-consumer.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pubsub-consumer.decorator.d.ts","sourceRoot":"","sources":["../../src/decorators/pubsub-consumer.decorator.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAC1B,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAGxD,eAAO,MAAM,4BAA4B,eAA4B,CAAC;AAEtE,wBAAgB,cAAc,CAAC,OAAO,GAAE,qBAA0B,GAAG,cAAc,CAalF;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,GAAG,qBAAqB,GAAG,SAAS,CAK3F;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAKxD"}

package/dist/decorators/pubsub-consumer.decorator.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PUBSUB_CONSUMER_METADATA_KEY = void 0;
+exports.PubSubConsumer = PubSubConsumer;
+exports.getPubSubConsumerMetadata = getPubSubConsumerMetadata;
+exports.isPubSubConsumer = isPubSubConsumer;
+require("reflect-metadata");
+const core_1 = __importDefault(require("@hazeljs/core"));
+exports.PUBSUB_CONSUMER_METADATA_KEY = Symbol('pubsub:consumer');
+function PubSubConsumer(options = {}) {
+    return (target) => {
+        const defaults = {
+            ackOnSuccess: options.ackOnSuccess ?? true,
+            nackOnError: options.nackOnError ?? true,
+            parseJson: options.parseJson ?? true,
+            autoCreateSubscription: options.autoCreateSubscription ?? false,
+        };
+        const targetName = typeof target === 'function' ? target.name : 'unknown';
+        core_1.default.debug(`Marking ${targetName} as Pub/Sub consumer`);
+        Reflect.defineMetadata(exports.PUBSUB_CONSUMER_METADATA_KEY, defaults, target);
+    };
+}
+function getPubSubConsumerMetadata(target) {
+    const constructor = typeof target === 'function' ? target : target.constructor;
+    if (!constructor)
+        return undefined;
+    return Reflect.getMetadata(exports.PUBSUB_CONSUMER_METADATA_KEY, constructor);
+}
+function isPubSubConsumer(target) {
+    const constructor = typeof target === 'function' ? target : target.constructor;
+    if (!constructor)
+        return false;
+    return Reflect.hasMetadata(exports.PUBSUB_CONSUMER_METADATA_KEY, constructor);
+}

package/dist/decorators/pubsub-subscribe.decorator.d.ts

@@ -0,0 +1,6 @@
+import 'reflect-metadata';
+import { PubSubSubscribeMetadata, PubSubSubscribeOptions } from '../pubsub.types';
+export declare const PUBSUB_SUBSCRIBE_METADATA_KEY: unique symbol;
+export declare function PubSubSubscribe(options: PubSubSubscribeOptions): MethodDecorator;
+export declare function getPubSubSubscribeMetadata(target: object): PubSubSubscribeMetadata[];
+//# sourceMappingURL=pubsub-subscribe.decorator.d.ts.map

package/dist/decorators/pubsub-subscribe.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pubsub-subscribe.decorator.d.ts","sourceRoot":"","sources":["../../src/decorators/pubsub-subscribe.decorator.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAC1B,OAAO,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAGlF,eAAO,MAAM,6BAA6B,eAA6B,CAAC;AAExE,wBAAgB,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,eAAe,CAqBhF;AAED,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM,GAAG,uBAAuB,EAAE,CAKpF"}

package/dist/decorators/pubsub-subscribe.decorator.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PUBSUB_SUBSCRIBE_METADATA_KEY = void 0;
+exports.PubSubSubscribe = PubSubSubscribe;
+exports.getPubSubSubscribeMetadata = getPubSubSubscribeMetadata;
+require("reflect-metadata");
+const core_1 = __importDefault(require("@hazeljs/core"));
+exports.PUBSUB_SUBSCRIBE_METADATA_KEY = Symbol('pubsub:subscribe');
+function PubSubSubscribe(options) {
+    return (target, propertyKey, _descriptor) => {
+        const existingSubscriptions = Reflect.getMetadata(exports.PUBSUB_SUBSCRIBE_METADATA_KEY, target.constructor) || [];
+        const subscription = {
+            methodName: propertyKey.toString(),
+            options,
+        };
+        existingSubscriptions.push(subscription);
+        Reflect.defineMetadata(exports.PUBSUB_SUBSCRIBE_METADATA_KEY, existingSubscriptions, target.constructor);
+        core_1.default.debug(`PubSubSubscribe applied to ${target.constructor.name}.${String(propertyKey)} for subscription: ${options.subscription}`);
+    };
+}
+function getPubSubSubscribeMetadata(target) {
+    const constructor = typeof target === 'function' ? target : target.constructor;
+    if (!constructor)
+        return [];
+    return Reflect.getMetadata(exports.PUBSUB_SUBSCRIBE_METADATA_KEY, constructor) || [];
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @hazeljs/pubsub - Google Cloud Pub/Sub module for HazelJS
+ */
+export { PubSubModule } from './pubsub.module';
+export { PubSubPublisherService, PUBSUB_CLIENT_TOKEN } from './pubsub-publisher.service';
+export { PubSubSubscriberService } from './pubsub-subscriber.service';
+export { PubSubConsumer, getPubSubConsumerMetadata, isPubSubConsumer, } from './decorators/pubsub-consumer.decorator';
+export { PubSubSubscribe, getPubSubSubscribeMetadata, } from './decorators/pubsub-subscribe.decorator';
+export type { PubSubClientOptions, PubSubModuleOptions, PubSubPublishOptions, PubSubSubscribeOptions, PubSubConsumerOptions, PubSubSubscribeMetadata, PubSubSubscriptionHandlerPayload, PubSubHandlerResult, } from './pubsub.types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACzF,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,EACL,cAAc,EACd,yBAAyB,EACzB,gBAAgB,GACjB,MAAM,wCAAwC,CAAC;AAChD,OAAO,EACL,eAAe,EACf,0BAA0B,GAC3B,MAAM,yCAAyC,CAAC;AACjD,YAAY,EACV,mBAAmB,EACnB,mBAAmB,EACnB,oBAAoB,EACpB,sBAAsB,EACtB,qBAAqB,EACrB,uBAAuB,EACvB,gCAAgC,EAChC,mBAAmB,GACpB,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * @hazeljs/pubsub - Google Cloud Pub/Sub module for HazelJS
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPubSubSubscribeMetadata = exports.PubSubSubscribe = exports.isPubSubConsumer = exports.getPubSubConsumerMetadata = exports.PubSubConsumer = exports.PubSubSubscriberService = exports.PUBSUB_CLIENT_TOKEN = exports.PubSubPublisherService = exports.PubSubModule = void 0;
+var pubsub_module_1 = require("./pubsub.module");
+Object.defineProperty(exports, "PubSubModule", { enumerable: true, get: function () { return pubsub_module_1.PubSubModule; } });
+var pubsub_publisher_service_1 = require("./pubsub-publisher.service");
+Object.defineProperty(exports, "PubSubPublisherService", { enumerable: true, get: function () { return pubsub_publisher_service_1.PubSubPublisherService; } });
+Object.defineProperty(exports, "PUBSUB_CLIENT_TOKEN", { enumerable: true, get: function () { return pubsub_publisher_service_1.PUBSUB_CLIENT_TOKEN; } });
+var pubsub_subscriber_service_1 = require("./pubsub-subscriber.service");
+Object.defineProperty(exports, "PubSubSubscriberService", { enumerable: true, get: function () { return pubsub_subscriber_service_1.PubSubSubscriberService; } });
+var pubsub_consumer_decorator_1 = require("./decorators/pubsub-consumer.decorator");
+Object.defineProperty(exports, "PubSubConsumer", { enumerable: true, get: function () { return pubsub_consumer_decorator_1.PubSubConsumer; } });
+Object.defineProperty(exports, "getPubSubConsumerMetadata", { enumerable: true, get: function () { return pubsub_consumer_decorator_1.getPubSubConsumerMetadata; } });
+Object.defineProperty(exports, "isPubSubConsumer", { enumerable: true, get: function () { return pubsub_consumer_decorator_1.isPubSubConsumer; } });
+var pubsub_subscribe_decorator_1 = require("./decorators/pubsub-subscribe.decorator");
+Object.defineProperty(exports, "PubSubSubscribe", { enumerable: true, get: function () { return pubsub_subscribe_decorator_1.PubSubSubscribe; } });
+Object.defineProperty(exports, "getPubSubSubscribeMetadata", { enumerable: true, get: function () { return pubsub_subscribe_decorator_1.getPubSubSubscribeMetadata; } });

package/dist/pubsub-publisher.service.d.ts

@@ -0,0 +1,13 @@
+import { PubSub } from '@google-cloud/pubsub';
+import { PubSubPublishOptions } from './pubsub.types';
+export declare const PUBSUB_CLIENT_TOKEN = "PUBSUB_CLIENT";
+export declare class PubSubPublisherService {
+    private readonly pubsub;
+    constructor(pubsub: PubSub);
+    publish(topicName: string, data: string | Buffer | object, options?: PubSubPublishOptions): Promise<string>;
+    publishJson<T extends object>(topicName: string, data: T, options?: Omit<PubSubPublishOptions, 'attributes'> & {
+        attributes?: Record<string, string>;
+    }): Promise<string>;
+    private toBuffer;
+}
+//# sourceMappingURL=pubsub-publisher.service.d.ts.map

package/dist/pubsub-publisher.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pubsub-publisher.service.d.ts","sourceRoot":"","sources":["../src/pubsub-publisher.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAC9C,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAGtD,eAAO,MAAM,mBAAmB,kBAAkB,CAAC;AAEnD,qBACa,sBAAsB;IAG/B,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,MAAM;IAG3B,OAAO,CACX,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAC9B,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,MAAM,CAAC;IAYZ,WAAW,CAAC,CAAC,SAAS,MAAM,EAChC,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,CAAC,EACP,OAAO,GAAE,IAAI,CAAC,oBAAoB,EAAE,YAAY,CAAC,GAAG;QAAE,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAAO,GAC/F,OAAO,CAAC,MAAM,CAAC;IAUlB,OAAO,CAAC,QAAQ;CAKjB"}

package/dist/pubsub-publisher.service.js

@@ -0,0 +1,60 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PubSubPublisherService = exports.PUBSUB_CLIENT_TOKEN = void 0;
+const core_1 = require("@hazeljs/core");
+const pubsub_1 = require("@google-cloud/pubsub");
+const core_2 = __importDefault(require("@hazeljs/core"));
+exports.PUBSUB_CLIENT_TOKEN = 'PUBSUB_CLIENT';
+let PubSubPublisherService = class PubSubPublisherService {
+    constructor(pubsub) {
+        this.pubsub = pubsub;
+    }
+    async publish(topicName, data, options = {}) {
+        const topic = this.pubsub.topic(topicName);
+        const payload = this.toBuffer(data);
+        const messageId = await topic.publishMessage({
+            data: payload,
+            attributes: options.attributes,
+            orderingKey: options.orderingKey,
+        });
+        core_2.default.debug(`Published Pub/Sub message to topic "${topicName}" (id: ${messageId})`);
+        return messageId;
+    }
+    async publishJson(topicName, data, options = {}) {
+        return this.publish(topicName, data, {
+            ...options,
+            attributes: {
+                'content-type': 'application/json',
+                ...(options.attributes ?? {}),
+            },
+        });
+    }
+    toBuffer(data) {
+        if (Buffer.isBuffer(data))
+            return data;
+        if (typeof data === 'string')
+            return Buffer.from(data);
+        return Buffer.from(JSON.stringify(data));
+    }
+};
+exports.PubSubPublisherService = PubSubPublisherService;
+exports.PubSubPublisherService = PubSubPublisherService = __decorate([
+    (0, core_1.Service)(),
+    __param(0, (0, core_1.Inject)(exports.PUBSUB_CLIENT_TOKEN)),
+    __metadata("design:paramtypes", [pubsub_1.PubSub])
+], PubSubPublisherService);