nestjs-temporal-core
Version:
Complete NestJS integration for Temporal.io with auto-discovery, declarative scheduling, enhanced monitoring, and enterprise-ready features
180 lines • 8.07 kB
JavaScript
;
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 TemporalModule_1;
Object.defineProperty(exports, "__esModule", { value: true });
exports.TemporalModule = void 0;
const common_1 = require("@nestjs/common");
const core_1 = require("@nestjs/core");
const temporal_service_1 = require("./temporal.service");
const constants_1 = require("./constants");
const client_1 = require("./client");
const worker_1 = require("./worker");
const discovery_1 = require("./discovery");
const logger_1 = require("./utils/logger");
let TemporalModule = TemporalModule_1 = class TemporalModule {
static register(options) {
this.validateOptions(options);
const imports = [];
const providers = [];
imports.push(client_1.TemporalClientModule.register(options));
if (options.worker && (options.worker.workflowsPath || options.worker.workflowBundle)) {
imports.push(worker_1.TemporalWorkerModule.register(options));
}
providers.push({
provide: constants_1.TEMPORAL_MODULE_OPTIONS,
useValue: options,
}, {
provide: logger_1.TemporalLoggerManager,
useFactory: () => {
const manager = logger_1.TemporalLoggerManager.getInstance();
manager.configure({
enableLogger: options.enableLogger,
logLevel: options.logLevel,
appName: 'NestJS-Temporal-Core',
});
return manager;
},
}, discovery_1.TemporalDiscoveryService, discovery_1.TemporalScheduleManagerService, temporal_service_1.TemporalService);
return {
module: TemporalModule_1,
imports: [core_1.DiscoveryModule, ...imports],
providers,
exports: [temporal_service_1.TemporalService, logger_1.TemporalLoggerManager, constants_1.TEMPORAL_MODULE_OPTIONS],
global: options.isGlobal,
};
}
static registerAsync(options) {
this.validateAsyncOptions(options);
const imports = [core_1.DiscoveryModule];
const providers = [];
if (options.useFactory) {
providers.push({
provide: constants_1.TEMPORAL_MODULE_OPTIONS,
useFactory: options.useFactory,
inject: options.inject || [],
});
}
else if (options.useClass) {
providers.push({
provide: options.useClass,
useClass: options.useClass,
}, {
provide: constants_1.TEMPORAL_MODULE_OPTIONS,
useFactory: async (optionsFactory) => optionsFactory.createTemporalOptions(),
inject: [options.useClass],
});
}
else if (options.useExisting) {
providers.push({
provide: constants_1.TEMPORAL_MODULE_OPTIONS,
useFactory: async (optionsFactory) => optionsFactory.createTemporalOptions(),
inject: [options.useExisting],
});
}
imports.push(client_1.TemporalClientModule.registerAsync({
imports: options.imports,
useFactory: async (...args) => {
const temporalOptions = await this.createOptionsFromFactory(options, args);
return temporalOptions;
},
inject: options.inject,
}));
imports.push(worker_1.TemporalWorkerModule.registerAsync({
imports: options.imports,
useFactory: async (...args) => {
const temporalOptions = await this.createOptionsFromFactory(options, args);
if (!temporalOptions.worker ||
(!temporalOptions.worker.workflowsPath &&
!temporalOptions.worker.workflowBundle)) {
const { worker: _worker, ...optionsWithoutWorker } = temporalOptions;
return optionsWithoutWorker;
}
return temporalOptions;
},
inject: options.inject,
}));
providers.push({
provide: logger_1.TemporalLoggerManager,
useFactory: async (...args) => {
const temporalOptions = await this.createOptionsFromFactory(options, args);
const manager = logger_1.TemporalLoggerManager.getInstance();
manager.configure({
enableLogger: temporalOptions.enableLogger,
logLevel: temporalOptions.logLevel,
appName: 'NestJS-Temporal-Core',
});
return manager;
},
inject: options.inject,
}, discovery_1.TemporalDiscoveryService, discovery_1.TemporalScheduleManagerService, temporal_service_1.TemporalService);
return {
module: TemporalModule_1,
imports: [...(options.imports || []), ...imports],
providers,
exports: [temporal_service_1.TemporalService, logger_1.TemporalLoggerManager, constants_1.TEMPORAL_MODULE_OPTIONS],
global: options.isGlobal,
};
}
static forClient(options) {
return this.register({
connection: options.connection,
enableLogger: options.enableLogger,
logLevel: options.logLevel,
isGlobal: options.isGlobal,
allowConnectionFailure: true,
});
}
static validateOptions(options) {
if (!options) {
throw new Error('Temporal options are required');
}
if (!options.connection) {
throw new Error('Connection configuration is required');
}
if (!options.connection.address) {
throw new Error('Connection address is required');
}
if (options.worker) {
const hasWorkflowsPath = Boolean(options.worker.workflowsPath);
const hasWorkflowBundle = Boolean(options.worker.workflowBundle);
if (hasWorkflowsPath && hasWorkflowBundle) {
throw new Error('Worker cannot have both workflowsPath and workflowBundle');
}
}
}
static validateAsyncOptions(options) {
const hasFactory = Boolean(options.useFactory);
const hasClass = Boolean(options.useClass);
const hasExisting = Boolean(options.useExisting);
const configMethods = [hasFactory, hasClass, hasExisting].filter(Boolean).length;
if (configMethods === 0) {
throw new Error(`${constants_1.ERRORS.INVALID_OPTIONS}: Must provide useFactory, useClass, or useExisting`);
}
if (configMethods > 1) {
throw new Error(`${constants_1.ERRORS.INVALID_OPTIONS}: Cannot provide multiple configuration methods`);
}
}
static async createOptionsFromFactory(options, args) {
if (options.useFactory) {
return await options.useFactory(...args);
}
if (options.useClass) {
const optionsFactory = new options.useClass();
return await optionsFactory.createTemporalOptions();
}
if (options.useExisting) {
throw new Error('useExisting should be handled by dependency injection');
}
throw new Error(constants_1.ERRORS.INVALID_OPTIONS);
}
};
exports.TemporalModule = TemporalModule;
exports.TemporalModule = TemporalModule = TemporalModule_1 = __decorate([
(0, common_1.Module)({})
], TemporalModule);
//# sourceMappingURL=temporal.module.js.map