@lyrolab/nest-shared 0.0.2 → 1.0.2

package/nest-cli.json

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

package/src/ai/ai.module.ts

@@ -1,8 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

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

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

@@ -1,27 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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/helpers/find-main-path.ts

@@ -1,22 +0,0 @@
-import { existsSync } from "fs"
-import { dirname, join } from "path"
-
-export function findMainPath() {
-  const rootPath = findUp("package.json", process.cwd())
-  if (!rootPath) throw new Error("package.json not found")
-  return rootPath
-}
-
-function findUp(path: string, cwd: string) {
-  const currentPath = cwd
-  const parentPath = dirname(currentPath)
-  if (parentPath === currentPath) {
-    return null
-  }
-
-  if (existsSync(join(currentPath, path))) {
-    return currentPath
-  }
-
-  return findUp(path, parentPath)
-}

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

@@ -1,137 +0,0 @@
-import { DynamicModule, Module, OnModuleDestroy } from "@nestjs/common"
-import { ConfigModule, ConfigService } from "@nestjs/config"
-import { TypeOrmModule, TypeOrmModuleOptions } from "@nestjs/typeorm"
-import { join } from "path"
-import { findMainPath } from "./helpers/find-main-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(findMainPath(), "**/*.entity{.ts,.js}"),
-    ]
-
-    const migrations = options.migrations || [
-      join(findMainPath(), "src/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

@@ -1,12 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

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

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

@@ -1,10 +0,0 @@
-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

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

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

@@ -1,53 +0,0 @@
-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

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

package/src/queue/queue.module.ts

@@ -1,14 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

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

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

@@ -1,66 +0,0 @@
-import { DynamicModule, Module, OnModuleDestroy } from "@nestjs/common"
-import { ConfigModule, ConfigService } from "@nestjs/config"
-import { GenericContainer, StartedTestContainer, Wait } from "testcontainers"
-import { RedisConfig } from "./redis.config"
-
-@Module({})
-export class SharedRedisModule implements OnModuleDestroy {
-  private static testContainer: StartedTestContainer | null = null
-
-  static forRoot(): DynamicModule {
-    return {
-      module: SharedRedisModule,
-      providers: [
-        {
-          provide: RedisConfig,
-          useFactory: async (configService: ConfigService) => {
-            const isTestEnvironment = process.env.NODE_ENV === "test"
-
-            if (isTestEnvironment) {
-              return new RedisConfig(await this.createTestConfiguration())
-            }
-
-            return new RedisConfig(
-              this.createProductionConfiguration(configService),
-            )
-          },
-          inject: [ConfigService],
-        },
-      ],
-      exports: [RedisConfig],
-      imports: [ConfigModule],
-      global: true,
-    }
-  }
-
-  private static async createTestConfiguration() {
-    if (!this.testContainer) {
-      this.testContainer = await new GenericContainer("redis")
-        .withExposedPorts(6379)
-        .withWaitStrategy(
-          Wait.forAll([
-            Wait.forListeningPorts(),
-            Wait.forLogMessage("Ready to accept connections tcp"),
-          ]),
-        )
-        .start()
-    }
-
-    return `redis://${this.testContainer.getHost()}:${this.testContainer.getMappedPort(6379)}`
-  }
-
-  private static createProductionConfiguration(configService: ConfigService) {
-    return configService.get("REDIS_URL") as string
-  }
-
-  static async closeTestConnection(): Promise<void> {
-    if (this.testContainer) {
-      await this.testContainer.stop()
-      this.testContainer = null
-    }
-  }
-
-  async onModuleDestroy() {
-    await SharedRedisModule.closeTestConnection()
-  }
-}

package/tsconfig.build.json

@@ -1,4 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]
-}

package/tsconfig.json

@@ -1,25 +0,0 @@
-{
-  "compilerOptions": {
-    "module": "commonjs",
-    "declaration": true,
-    "removeComments": true,
-    "emitDecoratorMetadata": true,
-    "experimentalDecorators": true,
-    "allowSyntheticDefaultImports": true,
-    "target": "ES2023",
-    "sourceMap": true,
-    "outDir": "./dist",
-    "baseUrl": "./",
-    "incremental": true,
-    "skipLibCheck": true,
-    "strictNullChecks": true,
-    "forceConsistentCasingInFileNames": true,
-    "noImplicitAny": true,
-    "strictBindCallApply": true,
-    "noFallthroughCasesInSwitch": true,
-    "paths": {
-      "@app/nest-shared": ["libs/nest-shared/src"],
-      "@app/nest-shared/*": ["libs/nest-shared/src/*"]
-    }
-  }
-}