@nexica/nestjs-trpc
Version:
NestJS TRPC Bridge
314 lines • 13.8 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 __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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var TRPCModule_1;
Object.defineProperty(exports, "__esModule", { value: true });
exports.TRPCModule = exports.TRPCProvidersModule = exports.TRPCHandler = exports.TRPC_ROUTER_INITIALIZED = exports.TRPC_MODULE_OPTIONS = exports.TRPC_ROUTER = void 0;
const common_1 = require("@nestjs/common");
const nestjs_discovery_1 = require("@golevelup/nestjs-discovery");
const core_1 = require("@nestjs/core");
const trpc_factory_1 = require("./factory/trpc.factory");
const trpc_driver_1 = require("./drivers/trpc.driver");
const express_driver_1 = require("./drivers/express.driver");
const fastify_driver_1 = require("./drivers/fastify.driver");
const app_router_provider_1 = require("./providers/app-router.provider");
const router_generator_1 = require("./generators/router-generator");
const error_handler_1 = require("./utils/error-handler");
exports.TRPC_ROUTER = 'TRPC_ROUTER';
exports.TRPC_MODULE_OPTIONS = 'TRPC_MODULE_OPTIONS';
exports.TRPC_ROUTER_INITIALIZED = 'TRPC_ROUTER_INITIALIZED';
var OperationMode;
(function (OperationMode) {
OperationMode["NORMAL"] = "normal";
OperationMode["SCHEMA_GENERATION"] = "schema_generation";
OperationMode["WATCH_MODE"] = "watch_mode";
})(OperationMode || (OperationMode = {}));
let TRPCHandler = class TRPCHandler {
constructor(options = {}, appRouterHost) {
Object.defineProperty(this, "options", {
enumerable: true,
configurable: true,
writable: true,
value: options
});
Object.defineProperty(this, "appRouterHost", {
enumerable: true,
configurable: true,
writable: true,
value: appRouterHost
});
Object.defineProperty(this, "routerInitialized", {
enumerable: true,
configurable: true,
writable: true,
value: false
});
Object.defineProperty(this, "dummyRouter", {
enumerable: true,
configurable: true,
writable: true,
value: {}
});
}
markInitialized() {
this.routerInitialized = true;
error_handler_1.ErrorHandler.logInfo('TRPCHandler', 'tRPC router has been successfully initialized');
}
isInitialized() {
return this.routerInitialized && !!this.appRouterHost.appRouter;
}
getAppRouter() {
if (!this.appRouterHost.appRouter) {
if (!this.routerInitialized) {
return this.dummyRouter;
}
error_handler_1.ErrorHandler.logError('TRPCHandler', 'tRPC router not initialized. Make sure TRPCModule.onModuleInit completed successfully.');
return this.dummyRouter;
}
return this.appRouterHost.appRouter;
}
};
exports.TRPCHandler = TRPCHandler;
exports.TRPCHandler = TRPCHandler = __decorate([
(0, common_1.Injectable)(),
__param(0, (0, common_1.Inject)(exports.TRPC_MODULE_OPTIONS)),
__param(0, (0, common_1.Optional)()),
__metadata("design:paramtypes", [Object, app_router_provider_1.TRPCAppRouter])
], TRPCHandler);
let TRPCProvidersModule = class TRPCProvidersModule {
};
exports.TRPCProvidersModule = TRPCProvidersModule;
exports.TRPCProvidersModule = TRPCProvidersModule = __decorate([
(0, common_1.Module)({
imports: [nestjs_discovery_1.DiscoveryModule],
providers: [trpc_factory_1.TRPCFactory, express_driver_1.ExpressDriver, fastify_driver_1.FastifyDriver],
exports: [trpc_factory_1.TRPCFactory, express_driver_1.ExpressDriver, fastify_driver_1.FastifyDriver, nestjs_discovery_1.DiscoveryModule],
})
], TRPCProvidersModule);
let TRPCModule = TRPCModule_1 = class TRPCModule {
constructor() {
Object.defineProperty(this, "options", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "trpcDriver", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "httpAdapterHost", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "trpcHandler", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "moduleRef", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
}
static forRoot(options = {}) {
const defaultOptions = {
outputPath: './../generated/server.ts',
generateSchemas: true,
};
const mergedOptions = Object.assign(Object.assign({}, defaultOptions), options);
TRPCModule_1.moduleOptions = mergedOptions;
return {
global: true,
module: TRPCModule_1,
imports: [TRPCProvidersModule],
providers: [
{
provide: exports.TRPC_MODULE_OPTIONS,
useValue: mergedOptions,
},
TRPCHandler,
trpc_driver_1.TRPCDriver,
app_router_provider_1.TRPCAppRouter,
router_generator_1.RouterGenerator,
{
provide: exports.TRPC_ROUTER,
useFactory: (handler) => {
return new Proxy({}, {
get(_, prop) {
const router = handler.getAppRouter();
return router[prop];
},
});
},
inject: [TRPCHandler],
},
],
exports: [exports.TRPC_ROUTER, TRPCHandler, app_router_provider_1.TRPCAppRouter, router_generator_1.RouterGenerator],
};
}
getOperationMode() {
const isSchemaGeneration = process.env.TRPC_SCHEMA_GENERATION === 'true';
const isWatchMode = process.env.TRPC_WATCH_MODE === 'true';
const isLegacySchemaWatch = process.env.TRPC_SCHEMA_GENERATION_WATCH === 'true';
if (isWatchMode || isLegacySchemaWatch) {
return OperationMode.WATCH_MODE;
}
if (isSchemaGeneration) {
return OperationMode.SCHEMA_GENERATION;
}
return OperationMode.NORMAL;
}
handleSchemaGeneration(continueAfterGeneration) {
return __awaiter(this, void 0, void 0, function* () {
error_handler_1.ErrorHandler.logInfo('TRPCModule', 'Running in schema generation mode');
yield this.trpcDriver.initializeRouter(TRPCModule_1.moduleOptions);
this.trpcHandler.markInitialized();
const routerGenerator = this.moduleRef.get(router_generator_1.RouterGenerator);
if (!routerGenerator) {
error_handler_1.ErrorHandler.logWarning('TRPCModule', 'RouterGenerator not available');
return;
}
const outputPath = TRPCModule_1.moduleOptions.outputPath;
if (!outputPath) {
error_handler_1.ErrorHandler.logWarning('TRPCModule', 'No output path specified for schema generation');
return;
}
error_handler_1.ErrorHandler.logInfo('TRPCModule', `Generating schema with output path: ${outputPath}`);
const schemaOptions = Object.assign(Object.assign({}, TRPCModule_1.moduleOptions), { outputPath });
routerGenerator.setOptions(schemaOptions);
try {
yield routerGenerator.generate();
error_handler_1.ErrorHandler.logInfo('TRPCModule', 'Schema generated successfully');
if (continueAfterGeneration) {
error_handler_1.ErrorHandler.logInfo('TRPCModule', 'Watch mode enabled - continuing to run for live schema updates');
}
else {
process.exit(0);
}
}
catch (error) {
error_handler_1.ErrorHandler.logError('TRPCModule', 'Error generating schema:', error);
throw error;
}
});
}
validateAndFixRouter() {
var _a;
const appRouter = this.trpcHandler.getAppRouter();
if (!((_a = appRouter === null || appRouter === void 0 ? void 0 : appRouter._def) === null || _a === void 0 ? void 0 : _a.procedures)) {
return;
}
const procedures = Object.values(appRouter._def.procedures);
for (const proc of procedures) {
const procedure = proc;
if ((procedure === null || procedure === void 0 ? void 0 : procedure._def) && !procedure._def.procedureType) {
if (procedure._def.query) {
procedure._def.procedureType = 'query';
}
else if (procedure._def.mutation) {
procedure._def.procedureType = 'mutation';
}
}
}
}
initializeNormalMode() {
return __awaiter(this, void 0, void 0, function* () {
var _a;
if (!((_a = this.httpAdapterHost) === null || _a === void 0 ? void 0 : _a.httpAdapter)) {
error_handler_1.ErrorHandler.logWarning('TRPCModule', 'HTTP adapter not available - tRPC initialization skipped');
return;
}
const success = yield this.trpcDriver.start(TRPCModule_1.moduleOptions);
if (success) {
this.trpcHandler.markInitialized();
this.validateAndFixRouter();
error_handler_1.ErrorHandler.logInfo('TRPCModule', 'tRPC module successfully initialized');
}
else {
error_handler_1.ErrorHandler.logWarning('TRPCModule', 'tRPC initialization failed but application will continue');
}
});
}
onModuleInit() {
return __awaiter(this, void 0, void 0, function* () {
try {
error_handler_1.ErrorHandler.logInfo('TRPCModule', 'Initializing tRPC module...');
const operationMode = this.getOperationMode();
switch (operationMode) {
case OperationMode.SCHEMA_GENERATION:
yield this.handleSchemaGeneration(false);
break;
case OperationMode.WATCH_MODE:
yield this.handleSchemaGeneration(true);
yield this.initializeNormalMode();
break;
case OperationMode.NORMAL:
default:
yield this.initializeNormalMode();
break;
}
}
catch (error) {
error_handler_1.ErrorHandler.logError('TRPCModule', 'Error initializing tRPC module:', error);
}
});
}
};
exports.TRPCModule = TRPCModule;
Object.defineProperty(TRPCModule, "moduleOptions", {
enumerable: true,
configurable: true,
writable: true,
value: {}
});
__decorate([
(0, common_1.Inject)(exports.TRPC_MODULE_OPTIONS),
__metadata("design:type", Object)
], TRPCModule.prototype, "options", void 0);
__decorate([
(0, common_1.Inject)(trpc_driver_1.TRPCDriver),
__metadata("design:type", trpc_driver_1.TRPCDriver)
], TRPCModule.prototype, "trpcDriver", void 0);
__decorate([
(0, common_1.Inject)(core_1.HttpAdapterHost),
__metadata("design:type", core_1.HttpAdapterHost)
], TRPCModule.prototype, "httpAdapterHost", void 0);
__decorate([
(0, common_1.Inject)(TRPCHandler),
__metadata("design:type", TRPCHandler)
], TRPCModule.prototype, "trpcHandler", void 0);
__decorate([
(0, common_1.Inject)(core_1.ModuleRef),
__metadata("design:type", core_1.ModuleRef)
], TRPCModule.prototype, "moduleRef", void 0);
exports.TRPCModule = TRPCModule = TRPCModule_1 = __decorate([
(0, common_1.Module)({})
], TRPCModule);
//# sourceMappingURL=module.js.map