@amqp-contract/worker-nestjs 0.3.2 → 0.3.4
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/index.cjs +55 -9
- package/dist/index.d.cts +89 -10
- package/dist/index.d.cts.map +1 -1
- package/dist/index.d.mts +89 -10
- package/dist/index.d.mts.map +1 -1
- package/dist/index.mjs +45 -11
- package/dist/index.mjs.map +1 -1
- package/docs/index.md +210 -104
- package/package.json +3 -3
package/dist/index.cjs
CHANGED
|
@@ -3,10 +3,10 @@ let _amqp_contract_worker = require("@amqp-contract/worker");
|
|
|
3
3
|
|
|
4
4
|
//#region src/worker.module-definition.ts
|
|
5
5
|
/**
|
|
6
|
-
*
|
|
7
|
-
*
|
|
6
|
+
* Injection token for AMQP worker module options
|
|
7
|
+
* Used by NestJS DI system to inject configuration into AmqpWorkerService
|
|
8
8
|
*/
|
|
9
|
-
const
|
|
9
|
+
const MODULE_OPTIONS_TOKEN = Symbol("AMQP_WORKER_MODULE_OPTIONS");
|
|
10
10
|
|
|
11
11
|
//#endregion
|
|
12
12
|
//#region \0@oxc-project+runtime@0.103.0/helpers/decorateMetadata.js
|
|
@@ -73,11 +73,45 @@ AmqpWorkerService = __decorate([
|
|
|
73
73
|
|
|
74
74
|
//#endregion
|
|
75
75
|
//#region src/worker.module.ts
|
|
76
|
-
|
|
77
|
-
AmqpWorkerModule =
|
|
78
|
-
|
|
79
|
-
|
|
80
|
-
|
|
76
|
+
var _AmqpWorkerModule;
|
|
77
|
+
let AmqpWorkerModule = _AmqpWorkerModule = class AmqpWorkerModule$1 {
|
|
78
|
+
/**
|
|
79
|
+
* Register the AMQP worker module with synchronous configuration
|
|
80
|
+
*
|
|
81
|
+
* @param options - The worker configuration options with contract and handlers
|
|
82
|
+
* @returns A dynamic module for NestJS
|
|
83
|
+
*/
|
|
84
|
+
static forRoot(options) {
|
|
85
|
+
return {
|
|
86
|
+
module: _AmqpWorkerModule,
|
|
87
|
+
providers: [{
|
|
88
|
+
provide: MODULE_OPTIONS_TOKEN,
|
|
89
|
+
useValue: options
|
|
90
|
+
}, AmqpWorkerService],
|
|
91
|
+
exports: [AmqpWorkerService]
|
|
92
|
+
};
|
|
93
|
+
}
|
|
94
|
+
/**
|
|
95
|
+
* Register the AMQP worker module with asynchronous configuration
|
|
96
|
+
*
|
|
97
|
+
* @param options - Async configuration options with factory function
|
|
98
|
+
* @returns A dynamic module for NestJS
|
|
99
|
+
*/
|
|
100
|
+
static forRootAsync(options) {
|
|
101
|
+
const providers = [{
|
|
102
|
+
provide: MODULE_OPTIONS_TOKEN,
|
|
103
|
+
useFactory: options.useFactory,
|
|
104
|
+
inject: options.inject || []
|
|
105
|
+
}, AmqpWorkerService];
|
|
106
|
+
return {
|
|
107
|
+
module: _AmqpWorkerModule,
|
|
108
|
+
imports: options.imports || [],
|
|
109
|
+
providers,
|
|
110
|
+
exports: [AmqpWorkerService]
|
|
111
|
+
};
|
|
112
|
+
}
|
|
113
|
+
};
|
|
114
|
+
AmqpWorkerModule = _AmqpWorkerModule = __decorate([(0, _nestjs_common.Module)({})], AmqpWorkerModule);
|
|
81
115
|
|
|
82
116
|
//#endregion
|
|
83
117
|
Object.defineProperty(exports, 'AmqpWorkerModule', {
|
|
@@ -92,4 +126,16 @@ Object.defineProperty(exports, 'AmqpWorkerService', {
|
|
|
92
126
|
return AmqpWorkerService;
|
|
93
127
|
}
|
|
94
128
|
});
|
|
95
|
-
exports.MODULE_OPTIONS_TOKEN = MODULE_OPTIONS_TOKEN;
|
|
129
|
+
exports.MODULE_OPTIONS_TOKEN = MODULE_OPTIONS_TOKEN;
|
|
130
|
+
Object.defineProperty(exports, 'defineHandler', {
|
|
131
|
+
enumerable: true,
|
|
132
|
+
get: function () {
|
|
133
|
+
return _amqp_contract_worker.defineHandler;
|
|
134
|
+
}
|
|
135
|
+
});
|
|
136
|
+
Object.defineProperty(exports, 'defineHandlers', {
|
|
137
|
+
enumerable: true,
|
|
138
|
+
get: function () {
|
|
139
|
+
return _amqp_contract_worker.defineHandlers;
|
|
140
|
+
}
|
|
141
|
+
});
|
package/dist/index.d.cts
CHANGED
|
@@ -1,5 +1,4 @@
|
|
|
1
|
-
import
|
|
2
|
-
import { OnModuleDestroy, OnModuleInit } from "@nestjs/common";
|
|
1
|
+
import { DynamicModule, ModuleMetadata, OnModuleDestroy, OnModuleInit, Type } from "@nestjs/common";
|
|
3
2
|
import { ContractDefinition } from "@amqp-contract/contract";
|
|
4
3
|
import { AmqpConnectionManagerOptions, ConnectionUrl } from "amqp-connection-manager";
|
|
5
4
|
import { WorkerInferConsumerHandler, WorkerInferConsumerHandlers, WorkerInferConsumerHandlers as WorkerInferConsumerHandlers$1, WorkerInferConsumerInput, defineHandler, defineHandlers } from "@amqp-contract/worker";
|
|
@@ -96,20 +95,100 @@ declare class AmqpWorkerService<TContract extends ContractDefinition> implements
|
|
|
96
95
|
onModuleDestroy(): Promise<void>;
|
|
97
96
|
}
|
|
98
97
|
//#endregion
|
|
99
|
-
//#region src/worker.module
|
|
98
|
+
//#region src/worker.module.d.ts
|
|
100
99
|
/**
|
|
101
|
-
*
|
|
102
|
-
* This creates forRoot and forRootAsync methods automatically
|
|
100
|
+
* Factory function return type for async module configuration
|
|
103
101
|
*/
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
102
|
+
type AmqpWorkerModuleOptionsFactory<TContract extends ContractDefinition> = AmqpWorkerModuleOptions<TContract> | Promise<AmqpWorkerModuleOptions<TContract>>;
|
|
103
|
+
/**
|
|
104
|
+
* Options for async module configuration using factory pattern
|
|
105
|
+
*/
|
|
106
|
+
interface AmqpWorkerModuleAsyncOptions<TContract extends ContractDefinition> {
|
|
107
|
+
/**
|
|
108
|
+
* Factory function that returns the module options.
|
|
109
|
+
* Can use injected dependencies to create configuration.
|
|
110
|
+
*/
|
|
111
|
+
useFactory: (...args: unknown[]) => AmqpWorkerModuleOptionsFactory<TContract>;
|
|
112
|
+
/**
|
|
113
|
+
* Optional dependencies to inject into the factory function.
|
|
114
|
+
* Can be a token (string/symbol) a class or a reference to a provider.
|
|
115
|
+
*/
|
|
116
|
+
inject?: (string | symbol | Type<unknown>)[];
|
|
117
|
+
/**
|
|
118
|
+
* Optional list of imported modules that export providers needed by the factory
|
|
119
|
+
*/
|
|
120
|
+
imports?: ModuleMetadata["imports"];
|
|
121
|
+
}
|
|
107
122
|
/**
|
|
108
123
|
* NestJS module for AMQP worker integration
|
|
109
124
|
* This module provides type-safe AMQP worker functionality using @amqp-contract/worker
|
|
110
125
|
* without relying on NestJS decorators (except for dependency injection)
|
|
126
|
+
*
|
|
127
|
+
* @typeParam TContract - The contract definition type for type-safe handlers
|
|
128
|
+
*
|
|
129
|
+
* @example
|
|
130
|
+
* ```typescript
|
|
131
|
+
* // Synchronous configuration
|
|
132
|
+
* @Module({
|
|
133
|
+
* imports: [
|
|
134
|
+
* AmqpWorkerModule.forRoot({
|
|
135
|
+
* contract: myContract,
|
|
136
|
+
* handlers: {
|
|
137
|
+
* processOrder: async (message) => {
|
|
138
|
+
* // message is fully typed based on the contract
|
|
139
|
+
* console.log('Order:', message.orderId);
|
|
140
|
+
* }
|
|
141
|
+
* },
|
|
142
|
+
* urls: ['amqp://localhost']
|
|
143
|
+
* })
|
|
144
|
+
* ]
|
|
145
|
+
* })
|
|
146
|
+
* export class AppModule {}
|
|
147
|
+
*
|
|
148
|
+
* // Asynchronous configuration
|
|
149
|
+
* @Module({
|
|
150
|
+
* imports: [
|
|
151
|
+
* AmqpWorkerModule.forRootAsync({
|
|
152
|
+
* imports: [ConfigModule],
|
|
153
|
+
* useFactory: (configService: ConfigService) => ({
|
|
154
|
+
* contract: myContract,
|
|
155
|
+
* handlers: {
|
|
156
|
+
* processOrder: async (message) => {
|
|
157
|
+
* console.log('Order:', message.orderId);
|
|
158
|
+
* }
|
|
159
|
+
* },
|
|
160
|
+
* urls: configService.get('AMQP_URLS')
|
|
161
|
+
* }),
|
|
162
|
+
* inject: [ConfigService]
|
|
163
|
+
* })
|
|
164
|
+
* ]
|
|
165
|
+
* })
|
|
166
|
+
* export class AppModule {}
|
|
167
|
+
* ```
|
|
168
|
+
*/
|
|
169
|
+
declare class AmqpWorkerModule {
|
|
170
|
+
/**
|
|
171
|
+
* Register the AMQP worker module with synchronous configuration
|
|
172
|
+
*
|
|
173
|
+
* @param options - The worker configuration options with contract and handlers
|
|
174
|
+
* @returns A dynamic module for NestJS
|
|
175
|
+
*/
|
|
176
|
+
static forRoot<TContract extends ContractDefinition>(options: AmqpWorkerModuleOptions<TContract>): DynamicModule;
|
|
177
|
+
/**
|
|
178
|
+
* Register the AMQP worker module with asynchronous configuration
|
|
179
|
+
*
|
|
180
|
+
* @param options - Async configuration options with factory function
|
|
181
|
+
* @returns A dynamic module for NestJS
|
|
182
|
+
*/
|
|
183
|
+
static forRootAsync<TContract extends ContractDefinition>(options: AmqpWorkerModuleAsyncOptions<TContract>): DynamicModule;
|
|
184
|
+
}
|
|
185
|
+
//#endregion
|
|
186
|
+
//#region src/worker.module-definition.d.ts
|
|
187
|
+
/**
|
|
188
|
+
* Injection token for AMQP worker module options
|
|
189
|
+
* Used by NestJS DI system to inject configuration into AmqpWorkerService
|
|
111
190
|
*/
|
|
112
|
-
declare
|
|
191
|
+
declare const MODULE_OPTIONS_TOKEN: unique symbol;
|
|
113
192
|
//#endregion
|
|
114
|
-
export { AmqpWorkerModule, type AmqpWorkerModuleOptions, AmqpWorkerService, MODULE_OPTIONS_TOKEN, type WorkerInferConsumerHandler, type WorkerInferConsumerHandlers, type WorkerInferConsumerInput,
|
|
193
|
+
export { AmqpWorkerModule, type AmqpWorkerModuleAsyncOptions, type AmqpWorkerModuleOptions, AmqpWorkerService, MODULE_OPTIONS_TOKEN, type WorkerInferConsumerHandler, type WorkerInferConsumerHandlers, type WorkerInferConsumerInput, defineHandler, defineHandlers };
|
|
115
194
|
//# sourceMappingURL=index.d.cts.map
|
package/dist/index.d.cts.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"index.d.cts","names":[],"sources":["../src/worker.service.ts","../src/worker.module
|
|
1
|
+
{"version":3,"file":"index.d.cts","names":[],"sources":["../src/worker.service.ts","../src/worker.module.ts","../src/worker.module-definition.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AA2BA;;;;;;;;AA6CA;;;;;;;;;;;UA7CiB,0CAA0C;ECbtD;EAAiD,QAAA,EDe1C,SCf0C;EAC1B;EAAxB,QAAA,EDgBQ,6BChBR,CDgBoC,SChBpC,CAAA;EACgC;EAAxB,IAAA,EDiBJ,aCjBI,EAAA;EAAR;EAAO,iBAAA,CAAA,EDmBW,4BCnBX,GAAA,SAAA;AAKX;;;;;;;AAgEA;;;;;;;;;;;;;ACjFA;;;;;;;;;;;;;;;cFqEa,oCAAoC,+BACpC,cAAc;;;uBAMG,wBAAwB;;;;;;;;;;;kBAa9B;;;;;;;;qBAWG;;;;;;;AA7E3B,KCbK,8BDamC,CAAA,kBCbc,kBDad,CAAA,GCZpC,uBDYoC,CCZZ,SDYY,CAAA,GCXpC,ODWoC,CCX5B,uBDW4B,CCXJ,SDWI,CAAA,CAAA;;;;AAI5B,UCVK,4BDUL,CAAA,kBCVoD,kBDUpD,CAAA,CAAA;EAEJ;;;AAuCR;EACiD,UAAA,EAAA,CAAA,GAAA,IAAA,EAAA,OAAA,EAAA,EAAA,GC/CX,8BD+CW,CC/CoB,SD+CpB,CAAA;EAOK;;;;EANzC,MAAA,CAAA,EAAA,CAAA,MAAA,GAAA,MAAA,GC3CiB,ID2CjB,CAAA,OAAA,CAAA,CAAA,EAAA;EAAc;;;YCvCf;;AA1B0E;;;;;;;;AAYtF;;;;;;;AAgEA;;;;;;;;;;;;;ACjFA;;;;;;;;;;;;;;;;;;;cDkFa,gBAAA;;;;;;;mCAOsB,6BACtB,wBAAwB,aAChC;;;;;;;wCAoBmC,6BAC3B,6BAA6B,aACrC;;;;;;;;cCjHQ"}
|
package/dist/index.d.mts
CHANGED
|
@@ -1,5 +1,4 @@
|
|
|
1
|
-
import
|
|
2
|
-
import { OnModuleDestroy, OnModuleInit } from "@nestjs/common";
|
|
1
|
+
import { DynamicModule, ModuleMetadata, OnModuleDestroy, OnModuleInit, Type } from "@nestjs/common";
|
|
3
2
|
import { WorkerInferConsumerHandler, WorkerInferConsumerHandlers, WorkerInferConsumerHandlers as WorkerInferConsumerHandlers$1, WorkerInferConsumerInput, defineHandler, defineHandlers } from "@amqp-contract/worker";
|
|
4
3
|
import { ContractDefinition } from "@amqp-contract/contract";
|
|
5
4
|
import { AmqpConnectionManagerOptions, ConnectionUrl } from "amqp-connection-manager";
|
|
@@ -96,20 +95,100 @@ declare class AmqpWorkerService<TContract extends ContractDefinition> implements
|
|
|
96
95
|
onModuleDestroy(): Promise<void>;
|
|
97
96
|
}
|
|
98
97
|
//#endregion
|
|
99
|
-
//#region src/worker.module
|
|
98
|
+
//#region src/worker.module.d.ts
|
|
100
99
|
/**
|
|
101
|
-
*
|
|
102
|
-
* This creates forRoot and forRootAsync methods automatically
|
|
100
|
+
* Factory function return type for async module configuration
|
|
103
101
|
*/
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
102
|
+
type AmqpWorkerModuleOptionsFactory<TContract extends ContractDefinition> = AmqpWorkerModuleOptions<TContract> | Promise<AmqpWorkerModuleOptions<TContract>>;
|
|
103
|
+
/**
|
|
104
|
+
* Options for async module configuration using factory pattern
|
|
105
|
+
*/
|
|
106
|
+
interface AmqpWorkerModuleAsyncOptions<TContract extends ContractDefinition> {
|
|
107
|
+
/**
|
|
108
|
+
* Factory function that returns the module options.
|
|
109
|
+
* Can use injected dependencies to create configuration.
|
|
110
|
+
*/
|
|
111
|
+
useFactory: (...args: unknown[]) => AmqpWorkerModuleOptionsFactory<TContract>;
|
|
112
|
+
/**
|
|
113
|
+
* Optional dependencies to inject into the factory function.
|
|
114
|
+
* Can be a token (string/symbol) a class or a reference to a provider.
|
|
115
|
+
*/
|
|
116
|
+
inject?: (string | symbol | Type<unknown>)[];
|
|
117
|
+
/**
|
|
118
|
+
* Optional list of imported modules that export providers needed by the factory
|
|
119
|
+
*/
|
|
120
|
+
imports?: ModuleMetadata["imports"];
|
|
121
|
+
}
|
|
107
122
|
/**
|
|
108
123
|
* NestJS module for AMQP worker integration
|
|
109
124
|
* This module provides type-safe AMQP worker functionality using @amqp-contract/worker
|
|
110
125
|
* without relying on NestJS decorators (except for dependency injection)
|
|
126
|
+
*
|
|
127
|
+
* @typeParam TContract - The contract definition type for type-safe handlers
|
|
128
|
+
*
|
|
129
|
+
* @example
|
|
130
|
+
* ```typescript
|
|
131
|
+
* // Synchronous configuration
|
|
132
|
+
* @Module({
|
|
133
|
+
* imports: [
|
|
134
|
+
* AmqpWorkerModule.forRoot({
|
|
135
|
+
* contract: myContract,
|
|
136
|
+
* handlers: {
|
|
137
|
+
* processOrder: async (message) => {
|
|
138
|
+
* // message is fully typed based on the contract
|
|
139
|
+
* console.log('Order:', message.orderId);
|
|
140
|
+
* }
|
|
141
|
+
* },
|
|
142
|
+
* urls: ['amqp://localhost']
|
|
143
|
+
* })
|
|
144
|
+
* ]
|
|
145
|
+
* })
|
|
146
|
+
* export class AppModule {}
|
|
147
|
+
*
|
|
148
|
+
* // Asynchronous configuration
|
|
149
|
+
* @Module({
|
|
150
|
+
* imports: [
|
|
151
|
+
* AmqpWorkerModule.forRootAsync({
|
|
152
|
+
* imports: [ConfigModule],
|
|
153
|
+
* useFactory: (configService: ConfigService) => ({
|
|
154
|
+
* contract: myContract,
|
|
155
|
+
* handlers: {
|
|
156
|
+
* processOrder: async (message) => {
|
|
157
|
+
* console.log('Order:', message.orderId);
|
|
158
|
+
* }
|
|
159
|
+
* },
|
|
160
|
+
* urls: configService.get('AMQP_URLS')
|
|
161
|
+
* }),
|
|
162
|
+
* inject: [ConfigService]
|
|
163
|
+
* })
|
|
164
|
+
* ]
|
|
165
|
+
* })
|
|
166
|
+
* export class AppModule {}
|
|
167
|
+
* ```
|
|
168
|
+
*/
|
|
169
|
+
declare class AmqpWorkerModule {
|
|
170
|
+
/**
|
|
171
|
+
* Register the AMQP worker module with synchronous configuration
|
|
172
|
+
*
|
|
173
|
+
* @param options - The worker configuration options with contract and handlers
|
|
174
|
+
* @returns A dynamic module for NestJS
|
|
175
|
+
*/
|
|
176
|
+
static forRoot<TContract extends ContractDefinition>(options: AmqpWorkerModuleOptions<TContract>): DynamicModule;
|
|
177
|
+
/**
|
|
178
|
+
* Register the AMQP worker module with asynchronous configuration
|
|
179
|
+
*
|
|
180
|
+
* @param options - Async configuration options with factory function
|
|
181
|
+
* @returns A dynamic module for NestJS
|
|
182
|
+
*/
|
|
183
|
+
static forRootAsync<TContract extends ContractDefinition>(options: AmqpWorkerModuleAsyncOptions<TContract>): DynamicModule;
|
|
184
|
+
}
|
|
185
|
+
//#endregion
|
|
186
|
+
//#region src/worker.module-definition.d.ts
|
|
187
|
+
/**
|
|
188
|
+
* Injection token for AMQP worker module options
|
|
189
|
+
* Used by NestJS DI system to inject configuration into AmqpWorkerService
|
|
111
190
|
*/
|
|
112
|
-
declare
|
|
191
|
+
declare const MODULE_OPTIONS_TOKEN: unique symbol;
|
|
113
192
|
//#endregion
|
|
114
|
-
export { AmqpWorkerModule, type AmqpWorkerModuleOptions, AmqpWorkerService, MODULE_OPTIONS_TOKEN, type WorkerInferConsumerHandler, type WorkerInferConsumerHandlers, type WorkerInferConsumerInput,
|
|
193
|
+
export { AmqpWorkerModule, type AmqpWorkerModuleAsyncOptions, type AmqpWorkerModuleOptions, AmqpWorkerService, MODULE_OPTIONS_TOKEN, type WorkerInferConsumerHandler, type WorkerInferConsumerHandlers, type WorkerInferConsumerInput, defineHandler, defineHandlers };
|
|
115
194
|
//# sourceMappingURL=index.d.mts.map
|
package/dist/index.d.mts.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"index.d.mts","names":[],"sources":["../src/worker.service.ts","../src/worker.module
|
|
1
|
+
{"version":3,"file":"index.d.mts","names":[],"sources":["../src/worker.service.ts","../src/worker.module.ts","../src/worker.module-definition.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AA2BA;;;;;;;;AA6CA;;;;;;;;;;;UA7CiB,0CAA0C;ECbtD;EAAiD,QAAA,EDe1C,SCf0C;EAC1B;EAAxB,QAAA,EDgBQ,6BChBR,CDgBoC,SChBpC,CAAA;EACgC;EAAxB,IAAA,EDiBJ,aCjBI,EAAA;EAAR;EAAO,iBAAA,CAAA,EDmBW,4BCnBX,GAAA,SAAA;AAKX;;;;;;;AAgEA;;;;;;;;;;;;;ACjFA;;;;;;;;;;;;;;;cFqEa,oCAAoC,+BACpC,cAAc;;;uBAMG,wBAAwB;;;;;;;;;;;kBAa9B;;;;;;;;qBAWG;;;;;;;AA7E3B,KCbK,8BDamC,CAAA,kBCbc,kBDad,CAAA,GCZpC,uBDYoC,CCZZ,SDYY,CAAA,GCXpC,ODWoC,CCX5B,uBDW4B,CCXJ,SDWI,CAAA,CAAA;;;;AAI5B,UCVK,4BDUL,CAAA,kBCVoD,kBDUpD,CAAA,CAAA;EAEJ;;;AAuCR;EACiD,UAAA,EAAA,CAAA,GAAA,IAAA,EAAA,OAAA,EAAA,EAAA,GC/CX,8BD+CW,CC/CoB,SD+CpB,CAAA;EAOK;;;;EANzC,MAAA,CAAA,EAAA,CAAA,MAAA,GAAA,MAAA,GC3CiB,ID2CjB,CAAA,OAAA,CAAA,CAAA,EAAA;EAAc;;;YCvCf;;AA1B0E;;;;;;;;AAYtF;;;;;;;AAgEA;;;;;;;;;;;;;ACjFA;;;;;;;;;;;;;;;;;;;cDkFa,gBAAA;;;;;;;mCAOsB,6BACtB,wBAAwB,aAChC;;;;;;;wCAoBmC,6BAC3B,6BAA6B,aACrC;;;;;;;;cCjHQ"}
|
package/dist/index.mjs
CHANGED
|
@@ -1,12 +1,12 @@
|
|
|
1
|
-
import {
|
|
2
|
-
import { TypedAmqpWorker } from "@amqp-contract/worker";
|
|
1
|
+
import { Inject, Injectable, Module } from "@nestjs/common";
|
|
2
|
+
import { TypedAmqpWorker, defineHandler, defineHandlers } from "@amqp-contract/worker";
|
|
3
3
|
|
|
4
4
|
//#region src/worker.module-definition.ts
|
|
5
5
|
/**
|
|
6
|
-
*
|
|
7
|
-
*
|
|
6
|
+
* Injection token for AMQP worker module options
|
|
7
|
+
* Used by NestJS DI system to inject configuration into AmqpWorkerService
|
|
8
8
|
*/
|
|
9
|
-
const
|
|
9
|
+
const MODULE_OPTIONS_TOKEN = Symbol("AMQP_WORKER_MODULE_OPTIONS");
|
|
10
10
|
|
|
11
11
|
//#endregion
|
|
12
12
|
//#region \0@oxc-project+runtime@0.103.0/helpers/decorateMetadata.js
|
|
@@ -73,12 +73,46 @@ AmqpWorkerService = __decorate([
|
|
|
73
73
|
|
|
74
74
|
//#endregion
|
|
75
75
|
//#region src/worker.module.ts
|
|
76
|
-
|
|
77
|
-
AmqpWorkerModule =
|
|
78
|
-
|
|
79
|
-
|
|
80
|
-
|
|
76
|
+
var _AmqpWorkerModule;
|
|
77
|
+
let AmqpWorkerModule = _AmqpWorkerModule = class AmqpWorkerModule$1 {
|
|
78
|
+
/**
|
|
79
|
+
* Register the AMQP worker module with synchronous configuration
|
|
80
|
+
*
|
|
81
|
+
* @param options - The worker configuration options with contract and handlers
|
|
82
|
+
* @returns A dynamic module for NestJS
|
|
83
|
+
*/
|
|
84
|
+
static forRoot(options) {
|
|
85
|
+
return {
|
|
86
|
+
module: _AmqpWorkerModule,
|
|
87
|
+
providers: [{
|
|
88
|
+
provide: MODULE_OPTIONS_TOKEN,
|
|
89
|
+
useValue: options
|
|
90
|
+
}, AmqpWorkerService],
|
|
91
|
+
exports: [AmqpWorkerService]
|
|
92
|
+
};
|
|
93
|
+
}
|
|
94
|
+
/**
|
|
95
|
+
* Register the AMQP worker module with asynchronous configuration
|
|
96
|
+
*
|
|
97
|
+
* @param options - Async configuration options with factory function
|
|
98
|
+
* @returns A dynamic module for NestJS
|
|
99
|
+
*/
|
|
100
|
+
static forRootAsync(options) {
|
|
101
|
+
const providers = [{
|
|
102
|
+
provide: MODULE_OPTIONS_TOKEN,
|
|
103
|
+
useFactory: options.useFactory,
|
|
104
|
+
inject: options.inject || []
|
|
105
|
+
}, AmqpWorkerService];
|
|
106
|
+
return {
|
|
107
|
+
module: _AmqpWorkerModule,
|
|
108
|
+
imports: options.imports || [],
|
|
109
|
+
providers,
|
|
110
|
+
exports: [AmqpWorkerService]
|
|
111
|
+
};
|
|
112
|
+
}
|
|
113
|
+
};
|
|
114
|
+
AmqpWorkerModule = _AmqpWorkerModule = __decorate([Module({})], AmqpWorkerModule);
|
|
81
115
|
|
|
82
116
|
//#endregion
|
|
83
|
-
export { AmqpWorkerModule, AmqpWorkerService, MODULE_OPTIONS_TOKEN };
|
|
117
|
+
export { AmqpWorkerModule, AmqpWorkerService, MODULE_OPTIONS_TOKEN, defineHandler, defineHandlers };
|
|
84
118
|
//# sourceMappingURL=index.mjs.map
|
package/dist/index.mjs.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"index.mjs","names":["AmqpWorkerService","options: AmqpWorkerModuleOptions<TContract>","AmqpWorkerModule"],"sources":["../src/worker.module-definition.ts","../src/worker.service.ts","../src/worker.module.ts"],"sourcesContent":["
|
|
1
|
+
{"version":3,"file":"index.mjs","names":["AmqpWorkerService","options: AmqpWorkerModuleOptions<TContract>","AmqpWorkerModule","providers: Provider[]"],"sources":["../src/worker.module-definition.ts","../src/worker.service.ts","../src/worker.module.ts"],"sourcesContent":["/**\n * Injection token for AMQP worker module options\n * Used by NestJS DI system to inject configuration into AmqpWorkerService\n */\nexport const MODULE_OPTIONS_TOKEN = Symbol(\"AMQP_WORKER_MODULE_OPTIONS\");\n","import { Inject, Injectable, type OnModuleDestroy, type OnModuleInit } from \"@nestjs/common\";\nimport type { ContractDefinition } from \"@amqp-contract/contract\";\nimport type { AmqpConnectionManagerOptions, ConnectionUrl } from \"amqp-connection-manager\";\nimport { TypedAmqpWorker, type WorkerInferConsumerHandlers } from \"@amqp-contract/worker\";\nimport { MODULE_OPTIONS_TOKEN } from \"./worker.module-definition.js\";\n\n/**\n * Configuration options for the AMQP worker NestJS module.\n *\n * @typeParam TContract - The contract definition type\n *\n * @example\n * ```typescript\n * const options: AmqpWorkerModuleOptions<typeof contract> = {\n * contract: myContract,\n * handlers: {\n * processOrder: async (message) => {\n * console.log('Processing order:', message.orderId);\n * }\n * },\n * urls: ['amqp://localhost'],\n * connectionOptions: {\n * heartbeatIntervalInSeconds: 30\n * }\n * };\n * ```\n */\nexport interface AmqpWorkerModuleOptions<TContract extends ContractDefinition> {\n /** The AMQP contract definition specifying consumers and their message schemas */\n contract: TContract;\n /** Message handlers for each consumer defined in the contract */\n handlers: WorkerInferConsumerHandlers<TContract>;\n /** AMQP broker URL(s). Multiple URLs provide failover support */\n urls: ConnectionUrl[];\n /** Optional connection configuration (heartbeat, reconnect settings, etc.) */\n connectionOptions?: AmqpConnectionManagerOptions | undefined;\n}\n\n/**\n * Type-safe AMQP worker service for NestJS applications.\n *\n * This service wraps {@link TypedAmqpWorker} and integrates it with the NestJS\n * lifecycle, automatically starting message consumption on module init and\n * cleaning up resources on module destroy.\n *\n * @typeParam TContract - The contract definition type\n *\n * @example\n * ```typescript\n * // In your module\n * import { AmqpWorkerModule } from '@amqp-contract/worker-nestjs';\n *\n * @Module({\n * imports: [\n * AmqpWorkerModule.forRoot({\n * contract: myContract,\n * handlers: {\n * processOrder: async (message) => {\n * console.log('Received order:', message.orderId);\n * // Process the order...\n * }\n * },\n * urls: ['amqp://localhost']\n * })\n * ]\n * })\n * export class AppModule {}\n *\n * // The worker automatically starts consuming messages when the module initializes\n * // and stops gracefully when the application shuts down\n * ```\n */\n@Injectable()\nexport class AmqpWorkerService<TContract extends ContractDefinition>\n implements OnModuleInit, OnModuleDestroy\n{\n private worker: TypedAmqpWorker<TContract> | null = null;\n\n constructor(\n @Inject(MODULE_OPTIONS_TOKEN)\n private readonly options: AmqpWorkerModuleOptions<TContract>,\n ) {}\n\n /**\n * Initialize the AMQP worker when the NestJS module starts.\n *\n * This lifecycle hook automatically creates and starts the worker,\n * beginning message consumption from all configured consumers.\n * The connection will be established in the background with\n * automatic reconnection handling.\n *\n * @throws Error if the worker fails to start\n */\n async onModuleInit(): Promise<void> {\n this.worker = await TypedAmqpWorker.create(this.options).resultToPromise();\n }\n\n /**\n * Close the AMQP worker when the NestJS module is destroyed.\n *\n * This lifecycle hook ensures proper cleanup of resources when the\n * NestJS application shuts down, gracefully stopping message consumption\n * and closing the connection.\n */\n async onModuleDestroy(): Promise<void> {\n if (this.worker) {\n await this.worker.close().resultToPromise();\n this.worker = null;\n }\n }\n}\n","import {\n Module,\n type DynamicModule,\n type Provider,\n type Type,\n type ModuleMetadata,\n} from \"@nestjs/common\";\nimport type { ContractDefinition } from \"@amqp-contract/contract\";\nimport { MODULE_OPTIONS_TOKEN } from \"./worker.module-definition.js\";\nimport { AmqpWorkerService, type AmqpWorkerModuleOptions } from \"./worker.service.js\";\n\n/**\n * Factory function return type for async module configuration\n */\ntype AmqpWorkerModuleOptionsFactory<TContract extends ContractDefinition> =\n | AmqpWorkerModuleOptions<TContract>\n | Promise<AmqpWorkerModuleOptions<TContract>>;\n\n/**\n * Options for async module configuration using factory pattern\n */\nexport interface AmqpWorkerModuleAsyncOptions<TContract extends ContractDefinition> {\n /**\n * Factory function that returns the module options.\n * Can use injected dependencies to create configuration.\n */\n useFactory: (...args: unknown[]) => AmqpWorkerModuleOptionsFactory<TContract>;\n /**\n * Optional dependencies to inject into the factory function.\n * Can be a token (string/symbol) a class or a reference to a provider.\n */\n inject?: (string | symbol | Type<unknown>)[];\n /**\n * Optional list of imported modules that export providers needed by the factory\n */\n imports?: ModuleMetadata[\"imports\"];\n}\n\n/**\n * NestJS module for AMQP worker integration\n * This module provides type-safe AMQP worker functionality using @amqp-contract/worker\n * without relying on NestJS decorators (except for dependency injection)\n *\n * @typeParam TContract - The contract definition type for type-safe handlers\n *\n * @example\n * ```typescript\n * // Synchronous configuration\n * @Module({\n * imports: [\n * AmqpWorkerModule.forRoot({\n * contract: myContract,\n * handlers: {\n * processOrder: async (message) => {\n * // message is fully typed based on the contract\n * console.log('Order:', message.orderId);\n * }\n * },\n * urls: ['amqp://localhost']\n * })\n * ]\n * })\n * export class AppModule {}\n *\n * // Asynchronous configuration\n * @Module({\n * imports: [\n * AmqpWorkerModule.forRootAsync({\n * imports: [ConfigModule],\n * useFactory: (configService: ConfigService) => ({\n * contract: myContract,\n * handlers: {\n * processOrder: async (message) => {\n * console.log('Order:', message.orderId);\n * }\n * },\n * urls: configService.get('AMQP_URLS')\n * }),\n * inject: [ConfigService]\n * })\n * ]\n * })\n * export class AppModule {}\n * ```\n */\n@Module({})\nexport class AmqpWorkerModule {\n /**\n * Register the AMQP worker module with synchronous configuration\n *\n * @param options - The worker configuration options with contract and handlers\n * @returns A dynamic module for NestJS\n */\n static forRoot<TContract extends ContractDefinition>(\n options: AmqpWorkerModuleOptions<TContract>,\n ): DynamicModule {\n return {\n module: AmqpWorkerModule,\n providers: [\n {\n provide: MODULE_OPTIONS_TOKEN,\n useValue: options,\n },\n AmqpWorkerService,\n ],\n exports: [AmqpWorkerService],\n };\n }\n\n /**\n * Register the AMQP worker module with asynchronous configuration\n *\n * @param options - Async configuration options with factory function\n * @returns A dynamic module for NestJS\n */\n static forRootAsync<TContract extends ContractDefinition>(\n options: AmqpWorkerModuleAsyncOptions<TContract>,\n ): DynamicModule {\n const providers: Provider[] = [\n {\n provide: MODULE_OPTIONS_TOKEN,\n useFactory: options.useFactory,\n inject: options.inject || [],\n },\n AmqpWorkerService,\n ];\n\n return {\n module: AmqpWorkerModule,\n imports: options.imports || [],\n providers,\n exports: [AmqpWorkerService],\n };\n }\n}\n"],"mappings":";;;;;;;;AAIA,MAAa,uBAAuB,OAAO,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;ACqEjE,8BAAMA,oBAEb;CACE,AAAQ,SAA4C;CAEpD,YACE,AACiBC,SACjB;EADiB;;;;;;;;;;;;CAanB,MAAM,eAA8B;AAClC,OAAK,SAAS,MAAM,gBAAgB,OAAO,KAAK,QAAQ,CAAC,iBAAiB;;;;;;;;;CAU5E,MAAM,kBAAiC;AACrC,MAAI,KAAK,QAAQ;AACf,SAAM,KAAK,OAAO,OAAO,CAAC,iBAAiB;AAC3C,QAAK,SAAS;;;;;CAnCnB,YAAY;oBAOR,OAAO,qBAAqB;;;;;;;ACO1B,iDAAMC,mBAAiB;;;;;;;CAO5B,OAAO,QACL,SACe;AACf,SAAO;GACL;GACA,WAAW,CACT;IACE,SAAS;IACT,UAAU;IACX,EACD,kBACD;GACD,SAAS,CAAC,kBAAkB;GAC7B;;;;;;;;CASH,OAAO,aACL,SACe;EACf,MAAMC,YAAwB,CAC5B;GACE,SAAS;GACT,YAAY,QAAQ;GACpB,QAAQ,QAAQ,UAAU,EAAE;GAC7B,EACD,kBACD;AAED,SAAO;GACL;GACA,SAAS,QAAQ,WAAW,EAAE;GAC9B;GACA,SAAS,CAAC,kBAAkB;GAC7B;;;mDA/CJ,OAAO,EAAE,CAAC"}
|
package/docs/index.md
CHANGED
|
@@ -8,20 +8,55 @@
|
|
|
8
8
|
|
|
9
9
|
### AmqpWorkerModule
|
|
10
10
|
|
|
11
|
-
Defined in: [
|
|
11
|
+
Defined in: [worker-nestjs/src/worker.module.ts:87](https://github.com/btravers/amqp-contract/blob/66db432a8891328d5e6c37823e46346ad36cb1e7/packages/worker-nestjs/src/worker.module.ts#L87)
|
|
12
12
|
|
|
13
13
|
NestJS module for AMQP worker integration
|
|
14
14
|
This module provides type-safe AMQP worker functionality using @amqp-contract/worker
|
|
15
15
|
without relying on NestJS decorators (except for dependency injection)
|
|
16
16
|
|
|
17
|
-
####
|
|
17
|
+
#### Type Param
|
|
18
18
|
|
|
19
|
-
-
|
|
19
|
+
The contract definition type for type-safe handlers
|
|
20
20
|
|
|
21
|
-
####
|
|
21
|
+
#### Example
|
|
22
22
|
|
|
23
|
-
```
|
|
24
|
-
|
|
23
|
+
```typescript
|
|
24
|
+
// Synchronous configuration
|
|
25
|
+
@Module({
|
|
26
|
+
imports: [
|
|
27
|
+
AmqpWorkerModule.forRoot({
|
|
28
|
+
contract: myContract,
|
|
29
|
+
handlers: {
|
|
30
|
+
processOrder: async (message) => {
|
|
31
|
+
// message is fully typed based on the contract
|
|
32
|
+
console.log('Order:', message.orderId);
|
|
33
|
+
}
|
|
34
|
+
},
|
|
35
|
+
urls: ['amqp://localhost']
|
|
36
|
+
})
|
|
37
|
+
]
|
|
38
|
+
})
|
|
39
|
+
export class AppModule {}
|
|
40
|
+
|
|
41
|
+
// Asynchronous configuration
|
|
42
|
+
@Module({
|
|
43
|
+
imports: [
|
|
44
|
+
AmqpWorkerModule.forRootAsync({
|
|
45
|
+
imports: [ConfigModule],
|
|
46
|
+
useFactory: (configService: ConfigService) => ({
|
|
47
|
+
contract: myContract,
|
|
48
|
+
handlers: {
|
|
49
|
+
processOrder: async (message) => {
|
|
50
|
+
console.log('Order:', message.orderId);
|
|
51
|
+
}
|
|
52
|
+
},
|
|
53
|
+
urls: configService.get('AMQP_URLS')
|
|
54
|
+
}),
|
|
55
|
+
inject: [ConfigService]
|
|
56
|
+
})
|
|
57
|
+
]
|
|
58
|
+
})
|
|
59
|
+
export class AppModule {}
|
|
25
60
|
```
|
|
26
61
|
|
|
27
62
|
#### Constructors
|
|
@@ -32,30 +67,73 @@ without relying on NestJS decorators (except for dependency injection)
|
|
|
32
67
|
new AmqpWorkerModule(): AmqpWorkerModule;
|
|
33
68
|
```
|
|
34
69
|
|
|
35
|
-
Defined in: node\_modules/.pnpm/@nestjs+common@11.1.10\_reflect-metadata@0.2.2\_rxjs@7.8.2/node\_modules/@nestjs/common/module-utils/interfaces/configurable-module-cls.interface.d.ts:12
|
|
36
|
-
|
|
37
70
|
###### Returns
|
|
38
71
|
|
|
39
72
|
[`AmqpWorkerModule`](#amqpworkermodule)
|
|
40
73
|
|
|
41
|
-
|
|
74
|
+
#### Methods
|
|
75
|
+
|
|
76
|
+
##### forRoot()
|
|
42
77
|
|
|
43
78
|
```ts
|
|
44
|
-
|
|
79
|
+
static forRoot<TContract>(options): DynamicModule;
|
|
45
80
|
```
|
|
46
81
|
|
|
47
|
-
|
|
82
|
+
Defined in: [worker-nestjs/src/worker.module.ts:94](https://github.com/btravers/amqp-contract/blob/66db432a8891328d5e6c37823e46346ad36cb1e7/packages/worker-nestjs/src/worker.module.ts#L94)
|
|
83
|
+
|
|
84
|
+
Register the AMQP worker module with synchronous configuration
|
|
85
|
+
|
|
86
|
+
###### Type Parameters
|
|
87
|
+
|
|
88
|
+
| Type Parameter |
|
|
89
|
+
| ------ |
|
|
90
|
+
| `TContract` *extends* `ContractDefinition` |
|
|
91
|
+
|
|
92
|
+
###### Parameters
|
|
93
|
+
|
|
94
|
+
| Parameter | Type | Description |
|
|
95
|
+
| ------ | ------ | ------ |
|
|
96
|
+
| `options` | [`AmqpWorkerModuleOptions`](#amqpworkermoduleoptions)\<`TContract`\> | The worker configuration options with contract and handlers |
|
|
97
|
+
|
|
98
|
+
###### Returns
|
|
99
|
+
|
|
100
|
+
`DynamicModule`
|
|
101
|
+
|
|
102
|
+
A dynamic module for NestJS
|
|
103
|
+
|
|
104
|
+
##### forRootAsync()
|
|
105
|
+
|
|
106
|
+
```ts
|
|
107
|
+
static forRootAsync<TContract>(options): DynamicModule;
|
|
108
|
+
```
|
|
109
|
+
|
|
110
|
+
Defined in: [worker-nestjs/src/worker.module.ts:116](https://github.com/btravers/amqp-contract/blob/66db432a8891328d5e6c37823e46346ad36cb1e7/packages/worker-nestjs/src/worker.module.ts#L116)
|
|
111
|
+
|
|
112
|
+
Register the AMQP worker module with asynchronous configuration
|
|
113
|
+
|
|
114
|
+
###### Type Parameters
|
|
115
|
+
|
|
116
|
+
| Type Parameter |
|
|
117
|
+
| ------ |
|
|
118
|
+
| `TContract` *extends* `ContractDefinition` |
|
|
119
|
+
|
|
120
|
+
###### Parameters
|
|
48
121
|
|
|
49
|
-
|
|
|
50
|
-
| ------ | ------ | ------ |
|
|
51
|
-
|
|
|
52
|
-
|
|
122
|
+
| Parameter | Type | Description |
|
|
123
|
+
| ------ | ------ | ------ |
|
|
124
|
+
| `options` | [`AmqpWorkerModuleAsyncOptions`](#amqpworkermoduleasyncoptions)\<`TContract`\> | Async configuration options with factory function |
|
|
125
|
+
|
|
126
|
+
###### Returns
|
|
127
|
+
|
|
128
|
+
`DynamicModule`
|
|
129
|
+
|
|
130
|
+
A dynamic module for NestJS
|
|
53
131
|
|
|
54
132
|
***
|
|
55
133
|
|
|
56
134
|
### AmqpWorkerService
|
|
57
135
|
|
|
58
|
-
Defined in: [
|
|
136
|
+
Defined in: [worker-nestjs/src/worker.service.ts:74](https://github.com/btravers/amqp-contract/blob/66db432a8891328d5e6c37823e46346ad36cb1e7/packages/worker-nestjs/src/worker.service.ts#L74)
|
|
59
137
|
|
|
60
138
|
Type-safe AMQP worker service for NestJS applications.
|
|
61
139
|
|
|
@@ -108,7 +186,7 @@ export class AppModule {}
|
|
|
108
186
|
new AmqpWorkerService<TContract>(options): AmqpWorkerService<TContract>;
|
|
109
187
|
```
|
|
110
188
|
|
|
111
|
-
Defined in: [
|
|
189
|
+
Defined in: [worker-nestjs/src/worker.service.ts:79](https://github.com/btravers/amqp-contract/blob/66db432a8891328d5e6c37823e46346ad36cb1e7/packages/worker-nestjs/src/worker.service.ts#L79)
|
|
112
190
|
|
|
113
191
|
###### Parameters
|
|
114
192
|
|
|
@@ -128,7 +206,7 @@ Defined in: [packages/worker-nestjs/src/worker.service.ts:79](https://github.com
|
|
|
128
206
|
onModuleDestroy(): Promise<void>;
|
|
129
207
|
```
|
|
130
208
|
|
|
131
|
-
Defined in: [
|
|
209
|
+
Defined in: [worker-nestjs/src/worker.service.ts:105](https://github.com/btravers/amqp-contract/blob/66db432a8891328d5e6c37823e46346ad36cb1e7/packages/worker-nestjs/src/worker.service.ts#L105)
|
|
132
210
|
|
|
133
211
|
Close the AMQP worker when the NestJS module is destroyed.
|
|
134
212
|
|
|
@@ -152,7 +230,7 @@ OnModuleDestroy.onModuleDestroy
|
|
|
152
230
|
onModuleInit(): Promise<void>;
|
|
153
231
|
```
|
|
154
232
|
|
|
155
|
-
Defined in: [
|
|
233
|
+
Defined in: [worker-nestjs/src/worker.service.ts:94](https://github.com/btravers/amqp-contract/blob/66db432a8891328d5e6c37823e46346ad36cb1e7/packages/worker-nestjs/src/worker.service.ts#L94)
|
|
156
234
|
|
|
157
235
|
Initialize the AMQP worker when the NestJS module starts.
|
|
158
236
|
|
|
@@ -177,9 +255,31 @@ OnModuleInit.onModuleInit
|
|
|
177
255
|
|
|
178
256
|
## Interfaces
|
|
179
257
|
|
|
258
|
+
### AmqpWorkerModuleAsyncOptions
|
|
259
|
+
|
|
260
|
+
Defined in: [worker-nestjs/src/worker.module.ts:22](https://github.com/btravers/amqp-contract/blob/66db432a8891328d5e6c37823e46346ad36cb1e7/packages/worker-nestjs/src/worker.module.ts#L22)
|
|
261
|
+
|
|
262
|
+
Options for async module configuration using factory pattern
|
|
263
|
+
|
|
264
|
+
#### Type Parameters
|
|
265
|
+
|
|
266
|
+
| Type Parameter |
|
|
267
|
+
| ------ |
|
|
268
|
+
| `TContract` *extends* `ContractDefinition` |
|
|
269
|
+
|
|
270
|
+
#### Properties
|
|
271
|
+
|
|
272
|
+
| Property | Type | Description | Defined in |
|
|
273
|
+
| ------ | ------ | ------ | ------ |
|
|
274
|
+
| <a id="imports"></a> `imports?` | ( \| `DynamicModule` \| `Type`\<`any`\> \| `Promise`\<`DynamicModule`\> \| `ForwardReference`\<`any`\>)[] | Optional list of imported modules that export providers needed by the factory | [worker-nestjs/src/worker.module.ts:36](https://github.com/btravers/amqp-contract/blob/66db432a8891328d5e6c37823e46346ad36cb1e7/packages/worker-nestjs/src/worker.module.ts#L36) |
|
|
275
|
+
| <a id="inject"></a> `inject?` | (`string` \| `symbol` \| `Type`\<`unknown`\>)[] | Optional dependencies to inject into the factory function. Can be a token (string/symbol) a class or a reference to a provider. | [worker-nestjs/src/worker.module.ts:32](https://github.com/btravers/amqp-contract/blob/66db432a8891328d5e6c37823e46346ad36cb1e7/packages/worker-nestjs/src/worker.module.ts#L32) |
|
|
276
|
+
| <a id="usefactory"></a> `useFactory` | (...`args`) => `AmqpWorkerModuleOptionsFactory`\<`TContract`\> | Factory function that returns the module options. Can use injected dependencies to create configuration. | [worker-nestjs/src/worker.module.ts:27](https://github.com/btravers/amqp-contract/blob/66db432a8891328d5e6c37823e46346ad36cb1e7/packages/worker-nestjs/src/worker.module.ts#L27) |
|
|
277
|
+
|
|
278
|
+
***
|
|
279
|
+
|
|
180
280
|
### AmqpWorkerModuleOptions
|
|
181
281
|
|
|
182
|
-
Defined in: [
|
|
282
|
+
Defined in: [worker-nestjs/src/worker.service.ts:28](https://github.com/btravers/amqp-contract/blob/66db432a8891328d5e6c37823e46346ad36cb1e7/packages/worker-nestjs/src/worker.service.ts#L28)
|
|
183
283
|
|
|
184
284
|
Configuration options for the AMQP worker NestJS module.
|
|
185
285
|
|
|
@@ -210,20 +310,102 @@ const options: AmqpWorkerModuleOptions<typeof contract> = {
|
|
|
210
310
|
|
|
211
311
|
| Property | Type | Description | Defined in |
|
|
212
312
|
| ------ | ------ | ------ | ------ |
|
|
213
|
-
| <a id="connectionoptions"></a> `connectionOptions?` | `AmqpConnectionManagerOptions` | Optional connection configuration (heartbeat, reconnect settings, etc.) | [
|
|
214
|
-
| <a id="contract"></a> `contract` | `TContract` | The AMQP contract definition specifying consumers and their message schemas | [
|
|
215
|
-
| <a id="handlers"></a> `handlers` | [`WorkerInferConsumerHandlers`](#workerinferconsumerhandlers)\<`TContract`\> | Message handlers for each consumer defined in the contract | [
|
|
216
|
-
| <a id="urls"></a> `urls` | `ConnectionUrl`[] | AMQP broker URL(s). Multiple URLs provide failover support | [
|
|
313
|
+
| <a id="connectionoptions"></a> `connectionOptions?` | `AmqpConnectionManagerOptions` | Optional connection configuration (heartbeat, reconnect settings, etc.) | [worker-nestjs/src/worker.service.ts:36](https://github.com/btravers/amqp-contract/blob/66db432a8891328d5e6c37823e46346ad36cb1e7/packages/worker-nestjs/src/worker.service.ts#L36) |
|
|
314
|
+
| <a id="contract"></a> `contract` | `TContract` | The AMQP contract definition specifying consumers and their message schemas | [worker-nestjs/src/worker.service.ts:30](https://github.com/btravers/amqp-contract/blob/66db432a8891328d5e6c37823e46346ad36cb1e7/packages/worker-nestjs/src/worker.service.ts#L30) |
|
|
315
|
+
| <a id="handlers"></a> `handlers` | [`WorkerInferConsumerHandlers`](#workerinferconsumerhandlers)\<`TContract`\> | Message handlers for each consumer defined in the contract | [worker-nestjs/src/worker.service.ts:32](https://github.com/btravers/amqp-contract/blob/66db432a8891328d5e6c37823e46346ad36cb1e7/packages/worker-nestjs/src/worker.service.ts#L32) |
|
|
316
|
+
| <a id="urls"></a> `urls` | `ConnectionUrl`[] | AMQP broker URL(s). Multiple URLs provide failover support | [worker-nestjs/src/worker.service.ts:34](https://github.com/btravers/amqp-contract/blob/66db432a8891328d5e6c37823e46346ad36cb1e7/packages/worker-nestjs/src/worker.service.ts#L34) |
|
|
217
317
|
|
|
218
318
|
## Type Aliases
|
|
219
319
|
|
|
320
|
+
### WorkerInferConsumerHandler()
|
|
321
|
+
|
|
322
|
+
```ts
|
|
323
|
+
type WorkerInferConsumerHandler<TContract, TName> = (message) => Promise<void>;
|
|
324
|
+
```
|
|
325
|
+
|
|
326
|
+
Defined in: worker/dist/index.d.mts:55
|
|
327
|
+
|
|
328
|
+
Infer consumer handler type for a specific consumer
|
|
329
|
+
|
|
330
|
+
#### Type Parameters
|
|
331
|
+
|
|
332
|
+
| Type Parameter |
|
|
333
|
+
| ------ |
|
|
334
|
+
| `TContract` *extends* `ContractDefinition` |
|
|
335
|
+
| `TName` *extends* `InferConsumerNames`\<`TContract`\> |
|
|
336
|
+
|
|
337
|
+
#### Parameters
|
|
338
|
+
|
|
339
|
+
| Parameter | Type |
|
|
340
|
+
| ------ | ------ |
|
|
341
|
+
| `message` | [`WorkerInferConsumerInput`](#workerinferconsumerinput)\<`TContract`, `TName`\> |
|
|
342
|
+
|
|
343
|
+
#### Returns
|
|
344
|
+
|
|
345
|
+
`Promise`\<`void`\>
|
|
346
|
+
|
|
347
|
+
***
|
|
348
|
+
|
|
349
|
+
### WorkerInferConsumerHandlers
|
|
350
|
+
|
|
351
|
+
```ts
|
|
352
|
+
type WorkerInferConsumerHandlers<TContract> = { [K in InferConsumerNames<TContract>]: WorkerInferConsumerHandler<TContract, K> };
|
|
353
|
+
```
|
|
354
|
+
|
|
355
|
+
Defined in: worker/dist/index.d.mts:59
|
|
356
|
+
|
|
357
|
+
Infer all consumer handlers for a contract
|
|
358
|
+
|
|
359
|
+
#### Type Parameters
|
|
360
|
+
|
|
361
|
+
| Type Parameter |
|
|
362
|
+
| ------ |
|
|
363
|
+
| `TContract` *extends* `ContractDefinition` |
|
|
364
|
+
|
|
365
|
+
***
|
|
366
|
+
|
|
367
|
+
### WorkerInferConsumerInput
|
|
368
|
+
|
|
369
|
+
```ts
|
|
370
|
+
type WorkerInferConsumerInput<TContract, TName> = ConsumerInferInput<InferConsumer<TContract, TName>>;
|
|
371
|
+
```
|
|
372
|
+
|
|
373
|
+
Defined in: worker/dist/index.d.mts:51
|
|
374
|
+
|
|
375
|
+
Worker perspective types - for consuming messages
|
|
376
|
+
|
|
377
|
+
#### Type Parameters
|
|
378
|
+
|
|
379
|
+
| Type Parameter |
|
|
380
|
+
| ------ |
|
|
381
|
+
| `TContract` *extends* `ContractDefinition` |
|
|
382
|
+
| `TName` *extends* `InferConsumerNames`\<`TContract`\> |
|
|
383
|
+
|
|
384
|
+
## Variables
|
|
385
|
+
|
|
386
|
+
### MODULE\_OPTIONS\_TOKEN
|
|
387
|
+
|
|
388
|
+
```ts
|
|
389
|
+
const MODULE_OPTIONS_TOKEN: typeof MODULE_OPTIONS_TOKEN;
|
|
390
|
+
```
|
|
391
|
+
|
|
392
|
+
Defined in: [worker-nestjs/src/worker.module-definition.ts:5](https://github.com/btravers/amqp-contract/blob/66db432a8891328d5e6c37823e46346ad36cb1e7/packages/worker-nestjs/src/worker.module-definition.ts#L5)
|
|
393
|
+
|
|
394
|
+
Injection token for AMQP worker module options
|
|
395
|
+
Used by NestJS DI system to inject configuration into AmqpWorkerService
|
|
396
|
+
|
|
397
|
+
## Functions
|
|
398
|
+
|
|
220
399
|
### defineHandler()
|
|
221
400
|
|
|
222
401
|
```ts
|
|
223
|
-
|
|
402
|
+
function defineHandler<TContract, TName>(
|
|
403
|
+
contract,
|
|
404
|
+
consumerName,
|
|
405
|
+
handler): WorkerInferConsumerHandler<TContract, TName>;
|
|
224
406
|
```
|
|
225
407
|
|
|
226
|
-
Defined in:
|
|
408
|
+
Defined in: worker/dist/index.d.mts:273
|
|
227
409
|
|
|
228
410
|
Define a type-safe handler for a specific consumer in a contract.
|
|
229
411
|
|
|
@@ -312,10 +494,10 @@ const worker = await TypedAmqpWorker.create({
|
|
|
312
494
|
### defineHandlers()
|
|
313
495
|
|
|
314
496
|
```ts
|
|
315
|
-
|
|
497
|
+
function defineHandlers<TContract>(contract, handlers): WorkerInferConsumerHandlers<TContract>;
|
|
316
498
|
```
|
|
317
499
|
|
|
318
|
-
Defined in:
|
|
500
|
+
Defined in: worker/dist/index.d.mts:330
|
|
319
501
|
|
|
320
502
|
Define multiple type-safe handlers for consumers in a contract.
|
|
321
503
|
|
|
@@ -385,79 +567,3 @@ const handlers = defineHandlers(orderContract, {
|
|
|
385
567
|
notifyOrder: handleNotifyOrder,
|
|
386
568
|
});
|
|
387
569
|
```
|
|
388
|
-
|
|
389
|
-
***
|
|
390
|
-
|
|
391
|
-
### WorkerInferConsumerHandler()
|
|
392
|
-
|
|
393
|
-
```ts
|
|
394
|
-
type WorkerInferConsumerHandler<TContract, TName> = (message) => Promise<void>;
|
|
395
|
-
```
|
|
396
|
-
|
|
397
|
-
Defined in: packages/worker/dist/index.d.mts:55
|
|
398
|
-
|
|
399
|
-
Infer consumer handler type for a specific consumer
|
|
400
|
-
|
|
401
|
-
#### Type Parameters
|
|
402
|
-
|
|
403
|
-
| Type Parameter |
|
|
404
|
-
| ------ |
|
|
405
|
-
| `TContract` *extends* `ContractDefinition` |
|
|
406
|
-
| `TName` *extends* `InferConsumerNames`\<`TContract`\> |
|
|
407
|
-
|
|
408
|
-
#### Parameters
|
|
409
|
-
|
|
410
|
-
| Parameter | Type |
|
|
411
|
-
| ------ | ------ |
|
|
412
|
-
| `message` | [`WorkerInferConsumerInput`](#workerinferconsumerinput)\<`TContract`, `TName`\> |
|
|
413
|
-
|
|
414
|
-
#### Returns
|
|
415
|
-
|
|
416
|
-
`Promise`\<`void`\>
|
|
417
|
-
|
|
418
|
-
***
|
|
419
|
-
|
|
420
|
-
### WorkerInferConsumerHandlers
|
|
421
|
-
|
|
422
|
-
```ts
|
|
423
|
-
type WorkerInferConsumerHandlers<TContract> = { [K in InferConsumerNames<TContract>]: WorkerInferConsumerHandler<TContract, K> };
|
|
424
|
-
```
|
|
425
|
-
|
|
426
|
-
Defined in: packages/worker/dist/index.d.mts:59
|
|
427
|
-
|
|
428
|
-
Infer all consumer handlers for a contract
|
|
429
|
-
|
|
430
|
-
#### Type Parameters
|
|
431
|
-
|
|
432
|
-
| Type Parameter |
|
|
433
|
-
| ------ |
|
|
434
|
-
| `TContract` *extends* `ContractDefinition` |
|
|
435
|
-
|
|
436
|
-
***
|
|
437
|
-
|
|
438
|
-
### WorkerInferConsumerInput
|
|
439
|
-
|
|
440
|
-
```ts
|
|
441
|
-
type WorkerInferConsumerInput<TContract, TName> = ConsumerInferInput<InferConsumer<TContract, TName>>;
|
|
442
|
-
```
|
|
443
|
-
|
|
444
|
-
Defined in: packages/worker/dist/index.d.mts:51
|
|
445
|
-
|
|
446
|
-
Worker perspective types - for consuming messages
|
|
447
|
-
|
|
448
|
-
#### Type Parameters
|
|
449
|
-
|
|
450
|
-
| Type Parameter |
|
|
451
|
-
| ------ |
|
|
452
|
-
| `TContract` *extends* `ContractDefinition` |
|
|
453
|
-
| `TName` *extends* `InferConsumerNames`\<`TContract`\> |
|
|
454
|
-
|
|
455
|
-
## Variables
|
|
456
|
-
|
|
457
|
-
### MODULE\_OPTIONS\_TOKEN
|
|
458
|
-
|
|
459
|
-
```ts
|
|
460
|
-
MODULE_OPTIONS_TOKEN: string | symbol;
|
|
461
|
-
```
|
|
462
|
-
|
|
463
|
-
Defined in: [packages/worker-nestjs/src/worker.module-definition.ts:9](https://github.com/btravers/amqp-contract/blob/2e0e3a372088cd269fea97fb73812491d1fc5e14/packages/worker-nestjs/src/worker.module-definition.ts#L9)
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@amqp-contract/worker-nestjs",
|
|
3
|
-
"version": "0.3.
|
|
3
|
+
"version": "0.3.4",
|
|
4
4
|
"description": "NestJS integration for @amqp-contract/worker",
|
|
5
5
|
"keywords": [
|
|
6
6
|
"amqp",
|
|
@@ -43,8 +43,8 @@
|
|
|
43
43
|
"docs"
|
|
44
44
|
],
|
|
45
45
|
"dependencies": {
|
|
46
|
-
"@amqp-contract/
|
|
47
|
-
"@amqp-contract/
|
|
46
|
+
"@amqp-contract/worker": "0.3.4",
|
|
47
|
+
"@amqp-contract/contract": "0.3.4"
|
|
48
48
|
},
|
|
49
49
|
"devDependencies": {
|
|
50
50
|
"@nestjs/common": "11.1.10",
|