@lyrolab/nest-shared 0.0.1

package/eslint.config.mjs

@@ -0,0 +1,35 @@
+// @ts-check
+import eslint from '@eslint/js';
+import eslintPluginPrettierRecommended from 'eslint-plugin-prettier/recommended';
+import globals from 'globals';
+import tseslint from 'typescript-eslint';
+
+export default tseslint.config(
+  {
+    ignores: ['eslint.config.mjs'],
+  },
+  eslint.configs.recommended,
+  ...tseslint.configs.recommendedTypeChecked,
+  eslintPluginPrettierRecommended,
+  {
+    languageOptions: {
+      globals: {
+        ...globals.node,
+        ...globals.jest,
+      },
+      ecmaVersion: 5,
+      sourceType: 'module',
+      parserOptions: {
+        projectService: true,
+        tsconfigRootDir: import.meta.dirname,
+      },
+    },
+  },
+  {
+    rules: {
+      '@typescript-eslint/no-explicit-any': 'off',
+      '@typescript-eslint/no-floating-promises': 'warn',
+      '@typescript-eslint/no-unsafe-argument': 'warn'
+    },
+  },
+);

package/nest-cli.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "https://json.schemastore.org/nest-cli",
+  "collection": "@nestjs/schematics",
+  "sourceRoot": "src",
+  "compilerOptions": {
+    "deleteOutDir": true,
+    "webpack": true
+  }
+}

package/package.json

@@ -0,0 +1,126 @@
+{
+  "name": "@lyrolab/nest-shared",
+  "version": "0.0.1",
+  "description": "",
+  "author": "",
+  "license": "UNLICENSED",
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-conventional"
+    ]
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "prebuild": "rimraf dist",
+    "build": "tsc -p tsconfig.build.json",
+    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\" \"libs/**/*.ts\"",
+    "start": "nest start",
+    "start:dev": "nest start --watch",
+    "start:debug": "nest start --debug --watch",
+    "start:prod": "node dist/main",
+    "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:cov": "jest --coverage",
+    "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
+    "test:e2e": "jest --config ./test/jest-e2e.json",
+    "prepare": "husky && npm run build",
+    "lint-staged": "npx lint-staged"
+  },
+  "dependencies": {
+    "@nestjs/common": "^11.0.1",
+    "@nestjs/platform-express": "^11.0.1",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.1"
+  },
+  "peerDependencies": {
+    "@nestjs/bullmq": "^11.0.0",
+    "@nestjs/cache-manager": "^3.0.0",
+    "@nestjs/config": "^4.0.0",
+    "@nestjs/typeorm": "^11.0.0",
+    "@openrouter/ai-sdk-provider": "^0.4.0",
+    "ai": "^4.2.0",
+    "bullmq": "^5.0.0",
+    "cache-manager": "^6.0.0",
+    "class-validator": "^0.14.0",
+    "testcontainers": "^10.0.0",
+    "typeorm": "^0.3.22"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^19.8.0",
+    "@commitlint/config-conventional": "^19.8.0",
+    "@eslint/eslintrc": "^3.2.0",
+    "@eslint/js": "^9.18.0",
+    "@keyv/redis": "^4.3.2",
+    "@nestjs/bullmq": "^11.0.2",
+    "@nestjs/cache-manager": "^3.0.1",
+    "@nestjs/cli": "^11.0.0",
+    "@nestjs/config": "^4.0.2",
+    "@nestjs/core": "^11.0.13",
+    "@nestjs/schematics": "^11.0.0",
+    "@nestjs/testing": "^11.0.1",
+    "@nestjs/typeorm": "^11.0.0",
+    "@openrouter/ai-sdk-provider": "^0.4.5",
+    "@swc/cli": "^0.6.0",
+    "@swc/core": "^1.10.7",
+    "@types/express": "^5.0.0",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.10.7",
+    "@types/supertest": "^6.0.2",
+    "ai": "^4.2.11",
+    "bullmq": "^5.46.1",
+    "cache-manager": "^6.4.1",
+    "class-validator": "^0.14.1",
+    "eslint": "^9.18.0",
+    "eslint-config-prettier": "^10.1.1",
+    "eslint-plugin-prettier": "^5.2.6",
+    "globals": "^16.0.0",
+    "husky": "^9.1.7",
+    "jest": "^29.7.0",
+    "prettier": "^3.5.3",
+    "rimraf": "^6.0.1",
+    "source-map-support": "^0.5.21",
+    "supertest": "^7.0.0",
+    "testcontainers": "^10.24.0",
+    "ts-jest": "^29.2.5",
+    "ts-loader": "^9.5.2",
+    "ts-node": "^10.9.2",
+    "tsconfig-paths": "^4.2.0",
+    "typeorm": "^0.3.22",
+    "typescript": "^5.7.3",
+    "typescript-eslint": "^8.20.0"
+  },
+  "jest": {
+    "moduleFileExtensions": [
+      "js",
+      "json",
+      "ts"
+    ],
+    "rootDir": ".",
+    "testRegex": ".*\\.spec\\.ts$",
+    "transform": {
+      "^.+\\.(t|j)s$": "ts-jest"
+    },
+    "collectCoverageFrom": [
+      "**/*.(t|j)s"
+    ],
+    "coverageDirectory": "./coverage",
+    "testEnvironment": "node",
+    "roots": [
+      "<rootDir>/src/",
+      "<rootDir>/libs/"
+    ],
+    "moduleNameMapper": {
+      "^@app/nest-shared(|/.*)$": "<rootDir>/libs/nest-shared/src/$1"
+    }
+  },
+  "lint-staged": {
+    "*.{js,ts,json,css,scss,md}": [
+      "prettier --write"
+    ],
+    "*.{js,ts}": [
+      "eslint --fix"
+    ]
+  }
+}

package/src/ai/ai.module.ts

@@ -0,0 +1,8 @@
+import { Module } from "@nestjs/common"
+import { AiService } from "./services/ai.service"
+
+@Module({
+  providers: [AiService],
+  exports: [AiService],
+})
+export class AiModule {}

package/src/ai/services/ai.service.ts

@@ -0,0 +1,51 @@
+import { CACHE_MANAGER } from "@nestjs/cache-manager"
+import { Inject, Injectable } from "@nestjs/common"
+import {
+  createOpenRouter,
+  OpenRouterProvider,
+} from "@openrouter/ai-sdk-provider"
+import {
+  LanguageModelV1,
+  LanguageModelV1Middleware,
+  wrapLanguageModel,
+} from "ai"
+import { Cache } from "cache-manager"
+
+@Injectable()
+export class AiService {
+  private readonly openrouter: OpenRouterProvider
+  private readonly openrouterChat: LanguageModelV1
+
+  constructor(@Inject(CACHE_MANAGER) private cache: Cache) {
+    this.openrouter = createOpenRouter({
+      apiKey: process.env.OPENROUTER_API_KEY,
+    })
+    this.openrouterChat = wrapLanguageModel({
+      model: this.openrouter.chat("google/gemini-2.0-flash-001"),
+      middleware: [{ wrapGenerate: (options) => this.wrapGenerate(options) }],
+    })
+  }
+
+  get model() {
+    return this.openrouterChat
+  }
+
+  private async wrapGenerate({
+    doGenerate,
+    params,
+  }: Parameters<
+    NonNullable<LanguageModelV1Middleware["wrapGenerate"]>
+  >[0]): Promise<Awaited<ReturnType<LanguageModelV1["doGenerate"]>>> {
+    const cacheKey = "ai:" + JSON.stringify(params)
+
+    const cachedResult = await this.cache.get(cacheKey)
+    if (cachedResult) {
+      return cachedResult as Awaited<ReturnType<LanguageModelV1["doGenerate"]>>
+    }
+
+    const result = await doGenerate()
+
+    await this.cache.set(cacheKey, result)
+    return result
+  }
+}

package/src/app.module.ts

@@ -0,0 +1,8 @@
+import { Module } from "@nestjs/common"
+
+@Module({
+  imports: [],
+  controllers: [],
+  providers: [],
+})
+export class AppModule {}

package/src/bull/shared-bull.module.ts

@@ -0,0 +1,27 @@
+import { BullModule } from "@nestjs/bullmq"
+import { DynamicModule, Module } from "@nestjs/common"
+import { ConfigModule } from "@nestjs/config"
+import { SharedRedisModule } from "../redis/shared-redis.module"
+import { RedisConfig } from "../redis/redis.config"
+
+@Module({})
+export class SharedBullModule {
+  static forRoot(): DynamicModule {
+    return {
+      module: SharedBullModule,
+      imports: [
+        SharedRedisModule,
+        BullModule.forRootAsync({
+          imports: [ConfigModule],
+          inject: [RedisConfig],
+          useFactory: (redisConfig: RedisConfig) => ({
+            connection: {
+              url: redisConfig.url,
+            },
+          }),
+        }),
+      ],
+      exports: [BullModule],
+    }
+  }
+}

package/src/cache/shared-cache.module.ts

@@ -0,0 +1,30 @@
+import KeyvRedis from "@keyv/redis"
+import { CacheModule } from "@nestjs/cache-manager"
+import { DynamicModule, Module } from "@nestjs/common"
+import { ConfigService } from "@nestjs/config"
+import { RedisConfig } from "../redis/redis.config"
+import { SharedRedisModule } from "../redis/shared-redis.module"
+
+@Module({})
+export class SharedCacheModule {
+  static forRoot(): DynamicModule {
+    return {
+      module: SharedCacheModule,
+      imports: [
+        SharedRedisModule,
+        CacheModule.registerAsync({
+          isGlobal: true,
+          useFactory: (
+            configService: ConfigService,
+            redisConfig: RedisConfig,
+          ) => ({
+            ttl: +configService.get("CACHE_TTL") * 1000,
+            stores: [new KeyvRedis(redisConfig.url)],
+          }),
+          inject: [ConfigService, RedisConfig],
+        }),
+      ],
+      exports: [CacheModule],
+    }
+  }
+}

package/src/database/filters/typeorm-exception.filter.ts

@@ -0,0 +1,35 @@
+import {
+  ExceptionFilter,
+  Catch,
+  ArgumentsHost,
+  NotFoundException,
+  Logger,
+} from "@nestjs/common"
+import { Response } from "express"
+import { EntityNotFoundError } from "typeorm"
+
+@Catch(EntityNotFoundError)
+export class TypeOrmExceptionFilter implements ExceptionFilter {
+  private readonly logger = new Logger(TypeOrmExceptionFilter.name)
+
+  catch(exception: EntityNotFoundError, host: ArgumentsHost) {
+    const ctx = host.switchToHttp()
+    const response = ctx.getResponse<Response>()
+
+    this.logger.debug(`Original TypeORM error: ${exception.message}`)
+
+    const entityName = this.extractEntityName(exception.message)
+    const message = entityName ? `${entityName} not found` : "Entity not found"
+
+    const notFoundException = new NotFoundException(message)
+
+    response
+      .status(notFoundException.getStatus())
+      .json(notFoundException.getResponse())
+  }
+
+  private extractEntityName(errorMessage: string): string | null {
+    const match = errorMessage.match(/entity of type "([^"]+)"/)
+    return match ? match[1] : null
+  }
+}

package/src/database/shared-database.module.ts

@@ -0,0 +1,136 @@
+import { DynamicModule, Module, OnModuleDestroy } from "@nestjs/common"
+import { ConfigModule, ConfigService } from "@nestjs/config"
+import { TypeOrmModule, TypeOrmModuleOptions } from "@nestjs/typeorm"
+import { join } from "path"
+import { GenericContainer, StartedTestContainer, Wait } from "testcontainers"
+import { DataSource } from "typeorm"
+
+type SharedDatabaseModuleOptions = {
+  entities?: string[]
+  migrations?: string[]
+}
+
+@Module({})
+export class SharedDatabaseModule implements OnModuleDestroy {
+  private static testContainer: StartedTestContainer
+  private static testDataSource: DataSource
+
+  static forRoot(options: SharedDatabaseModuleOptions = {}): DynamicModule {
+    return {
+      module: SharedDatabaseModule,
+      imports: [
+        TypeOrmModule.forRootAsync({
+          imports: [ConfigModule],
+          inject: [ConfigService],
+          useFactory: async (configService: ConfigService) => {
+            const isTestEnvironment = process.env.NODE_ENV === "test"
+
+            if (isTestEnvironment) {
+              return await this.createTestConfiguration(options)
+            }
+
+            return this.createProductionConfiguration(configService, options)
+          },
+        }),
+      ],
+      exports: [TypeOrmModule],
+    }
+  }
+
+  private static async createTestConfiguration(
+    options: SharedDatabaseModuleOptions,
+  ): Promise<TypeOrmModuleOptions> {
+    if (!this.testContainer) {
+      this.testContainer = await new GenericContainer("postgres")
+        .withExposedPorts(5432)
+        .withEnvironment({
+          POSTGRES_PASSWORD: "secret",
+          POSTGRES_DB: "test",
+        })
+        .withWaitStrategy(
+          Wait.forAll([
+            Wait.forListeningPorts(),
+            Wait.forLogMessage(
+              "database system is ready to accept connections",
+            ),
+          ]),
+        )
+        .start()
+    }
+
+    const connectionUri = `postgres://postgres:secret@localhost:${this.testContainer.getMappedPort(
+      5432,
+    )}/test`
+
+    const entities = options.entities || [
+      join(__dirname, "../../../**/*.entity{.ts,.js}"),
+    ]
+
+    const migrations = options.migrations || [
+      join(__dirname, "../../../migrations/**/*.{ts,js}"),
+    ]
+
+    if (!this.testDataSource) {
+      this.testDataSource = new DataSource({
+        type: "postgres",
+        url: connectionUri,
+        entities,
+        synchronize: true,
+        migrations,
+      })
+
+      await this.testDataSource.initialize()
+    }
+
+    return {
+      type: "postgres",
+      url: connectionUri,
+      entities,
+      synchronize: true,
+      autoLoadEntities: true,
+    }
+  }
+
+  private static createProductionConfiguration(
+    configService: ConfigService,
+    options: SharedDatabaseModuleOptions,
+  ): TypeOrmModuleOptions {
+    return {
+      type: "postgres",
+      url: configService.get("DATABASE_URL"),
+      entities: options.entities || [
+        join(__dirname, "../../../**/*.entity{.ts,.js}"),
+      ],
+      migrations: options.migrations || [
+        join(__dirname, "../../../migrations/**/*.{ts,js}"),
+      ],
+      synchronize: false,
+      autoLoadEntities: true,
+    }
+  }
+
+  static getTestDataSource(): DataSource {
+    return this.testDataSource
+  }
+
+  static async closeTestConnection(): Promise<void> {
+    if (this.testDataSource) {
+      await this.testDataSource.destroy()
+    }
+    if (this.testContainer) {
+      await this.testContainer.stop()
+    }
+  }
+
+  static async clearTestDatabase(): Promise<void> {
+    if (this.testDataSource) {
+      await this.testDataSource.synchronize(true)
+    }
+  }
+
+  async onModuleDestroy() {
+    if (SharedDatabaseModule.testDataSource) {
+      await SharedDatabaseModule.testDataSource.destroy()
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,12 @@
+export * from "./ai/ai.module"
+export * from "./ai/services/ai.service"
+export * from "./bull/shared-bull.module"
+export * from "./cache/shared-cache.module"
+export * from "./database/shared-database.module"
+export * from "./database/filters/typeorm-exception.filter"
+export * from "./queue/queue.module"
+export * from "./queue/services/queue.service"
+export * from "./queue/models/job-processor-interface"
+export * from "./queue/decorators/queue.decorator"
+export * from "./redis/shared-redis.module"
+export * from "./redis/redis.config"

package/src/queue/controllers/queue.controller.ts

@@ -0,0 +1,13 @@
+import { Body, Controller, Post } from "@nestjs/common"
+import { QueueService } from "../services/queue.service"
+import { QueueAddDto } from "../models/dto/queue-add.dto"
+
+@Controller("queue")
+export class QueueController {
+  constructor(private readonly queueService: QueueService) {}
+
+  @Post("add")
+  async add(@Body() body: QueueAddDto) {
+    return this.queueService.add(body.name, body.data)
+  }
+}

package/src/queue/decorators/queue.decorator.ts

@@ -0,0 +1,3 @@
+import { DiscoveryService } from "@nestjs/core"
+
+export const JobProcessor = DiscoveryService.createDecorator()

package/src/queue/models/dto/queue-add.dto.ts

@@ -0,0 +1,10 @@
+import { IsObject, IsOptional, IsString } from "class-validator"
+
+export class QueueAddDto {
+  @IsString()
+  name: string
+
+  @IsObject()
+  @IsOptional()
+  data?: Record<string, any>
+}

package/src/queue/models/job-processor-interface.ts

@@ -0,0 +1,5 @@
+import { Job } from "bullmq"
+
+export type JobProcessorInterface = {
+  process: (job: Job) => Promise<void>
+}

package/src/queue/processors/queue.processor.ts

@@ -0,0 +1,53 @@
+import { InjectQueue, Processor, WorkerHost } from "@nestjs/bullmq"
+import { DiscoveryService } from "@nestjs/core"
+import { Job, Queue } from "bullmq"
+import { JobProcessor } from "../decorators/queue.decorator"
+import { JobProcessorInterface } from "../models/job-processor-interface"
+import { DEFAULT_QUEUE } from "../queue.constants"
+
+@Processor(DEFAULT_QUEUE, { concurrency: 100 })
+export class QueueProcessor extends WorkerHost {
+  constructor(
+    private readonly discoveryService: DiscoveryService,
+    @InjectQueue(DEFAULT_QUEUE) private readonly queue: Queue,
+  ) {
+    super()
+  }
+
+  async process(job: Job) {
+    const jobProcessor = this.jobProcessorFor(job.name)
+    if (!jobProcessor) return
+
+    const shouldProcess = await this.shouldProcessJob(job)
+    if (!shouldProcess) return
+
+    try {
+      await jobProcessor.process(job)
+    } catch (error) {
+      console.error(error)
+    }
+  }
+
+  private jobProcessorFor(jobName: string) {
+    return this.discoveryService
+      .getProviders({ metadataKey: JobProcessor.KEY })
+      .find(
+        (provider) =>
+          this.discoveryService.getMetadataByDecorator(
+            JobProcessor,
+            provider,
+          ) === jobName,
+      )?.instance as JobProcessorInterface
+  }
+
+  private async shouldProcessJob(job: Job) {
+    if (!job.repeatJobKey) return true
+
+    const activeJobs = await this.queue.getActive()
+    const activeJobsOfSameCronjob = activeJobs.filter(
+      ({ name, id }) => name === job.name && id !== job.id,
+    )
+
+    return activeJobsOfSameCronjob.length === 0
+  }
+}

package/src/queue/queue.constants.ts

@@ -0,0 +1 @@
+export const DEFAULT_QUEUE = "default"

package/src/queue/queue.module.ts

@@ -0,0 +1,14 @@
+import { BullModule } from "@nestjs/bullmq"
+import { Module } from "@nestjs/common"
+import { DiscoveryModule } from "@nestjs/core"
+import { QueueProcessor } from "./processors/queue.processor"
+import { DEFAULT_QUEUE } from "./queue.constants"
+import { QueueService } from "./services/queue.service"
+import { QueueController } from "./controllers/queue.controller"
+@Module({
+  imports: [BullModule.registerQueue({ name: DEFAULT_QUEUE }), DiscoveryModule],
+  providers: [QueueService, QueueProcessor],
+  exports: [QueueService],
+  controllers: [QueueController],
+})
+export class QueueModule {}

package/src/queue/services/queue.service.ts

@@ -0,0 +1,17 @@
+import { InjectQueue } from "@nestjs/bullmq"
+import { Injectable } from "@nestjs/common"
+import { Job, JobsOptions, Queue } from "bullmq"
+import { DEFAULT_QUEUE } from "../queue.constants"
+
+@Injectable()
+export class QueueService {
+  constructor(@InjectQueue(DEFAULT_QUEUE) private readonly queue: Queue) {}
+
+  add(
+    name: string,
+    data: any,
+    opts?: JobsOptions,
+  ): Promise<Job<any, any, string>> {
+    return this.queue.add(name, data, opts)
+  }
+}

package/src/redis/redis.config.ts

@@ -0,0 +1,3 @@
+export class RedisConfig {
+  constructor(public readonly url: string) {}
+}