@nestledjs/api 2.1.0 → 2.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestledjs/api",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "generators": "./generators.json",
   "type": "commonjs",
   "main": "./src/index.js",

package/src/core/files/data-access/src/lib/api-core-data-access.module.ts__tmpl__

@@ -1,11 +1,9 @@
-import { Global, Module } from '@nestjs/common'
-import { ConfigModule } from '@<%= npmScope %>/api/config'
+import { Module, Global } from '@nestjs/common'
 
 import { ApiCoreDataAccessService } from './api-core-data-access.service'
 
 @Global()
 @Module({
-  imports: [ConfigModule],
   providers: [ApiCoreDataAccessService],
   exports: [ApiCoreDataAccessService],
 })

package/src/core/files/data-access/src/lib/api-core-data-access.service.ts__tmpl__

@@ -1,6 +1,5 @@
 import { Injectable, OnModuleDestroy, OnModuleInit } from '@nestjs/common'
 import { Prisma, PrismaClient } from '@<%= npmScope %>/api/prisma'
-import { ConfigService } from '@<%= npmScope %>/api/config'
 import { CorePagingInput } from './dto/core-paging.input'
 import { PrismaPg } from '@prisma/adapter-pg'
 
@@ -20,8 +19,9 @@ export class ApiCoreDataAccessService
   extends PrismaClient
   implements OnModuleInit, OnModuleDestroy
 {
-  constructor(private readonly configService: ConfigService) {
+  constructor() {
     const adapter = createAdapter()
+
     const config: Prisma.PrismaClientOptions = {
       adapter,
       log:
@@ -31,23 +31,19 @@ export class ApiCoreDataAccessService
           : [{ emit: 'event', level: 'warn' }],
     }
 
-    // Must call super first before accessing this
     super(config)
     this.queryCount = 0
 
-    // Check for Prisma Optimize setup using config service
-    const optimizeEnabled = configService.prismaOptimizeEnabled
-    const optimizeApiKey = configService.prismaOptimizeApiKey
+    // Only add Prisma Optimize extension in development
+    if (process.env['OPTIMIZE_API_KEY'] && process.env['USE_OPTIMIZE'] === 'true') {
+      const apiKey = process.env['OPTIMIZE_API_KEY']
+      if (!apiKey) {
+        console.warn('Not Running Prisma Optimize - No API Key Set')
+      }
 
-    if (optimizeEnabled && optimizeApiKey) {
-      console.log('🚀 Prisma Optimize enabled with API key')
       const { withOptimize } = require('@prisma/extension-optimize')
-      const extendedClient = new PrismaClient(config).$extends(
-        withOptimize({ apiKey: optimizeApiKey })
-      )
+      const extendedClient = new PrismaClient(config).$extends(withOptimize({ apiKey }))
       Object.assign(this, extendedClient)
-    } else if (optimizeEnabled && !optimizeApiKey) {
-        console.warn('⚠️  OPTIMIZE_ENABLED is true but OPTIMIZE_API_KEY is not set')
     }
   }
 

package/src/core/files/data-access/src/lib/api-core-pub-sub.ts__tmpl__

@@ -1,17 +1,24 @@
 import { Logger } from '@nestjs/common'
-import { PubSub } from 'graphql-subscriptions'
 import { RedisPubSub } from 'graphql-redis-subscriptions'
+import { PubSub } from 'graphql-subscriptions'
 import Redis from 'ioredis'
 
-// Support multiple Redis URL environment variables (Railway, Heroku, etc.)
+// Railway provides REDIS_URL (private) and REDIS_PASSWORD separately
+// REDIS_PUBLIC_URL is for external access, REDIS_URL is internal
 const REDIS_URL = process.env['REDIS_URL'] ?? process.env['REDIS_PRIVATE_URL'] ?? process.env['REDIS_TLS_URL'] ?? ''
-// Some PaaS providers (like Railway) provide password separately
 const REDIS_PASSWORD = process.env['REDIS_PASSWORD'] ?? ''
-const secure = REDIS_URL ? /rediss:/.test(REDIS_URL) : false
 
-// Only attempt Redis connection if we have a valid URL
+// Check if we have a valid Redis URL to connect to
 const hasValidRedisUrl = REDIS_URL && !REDIS_URL.includes('localhost') && REDIS_URL.length > 10
 
+const secure = REDIS_URL ? /rediss:/.test(REDIS_URL) : false
+
+if (hasValidRedisUrl) {
+  Logger.log(`🔴 Redis: Connecting to ${REDIS_URL.replace(/:[^:@]+@/, ':****@')} (password: ${REDIS_PASSWORD ? 'provided' : 'none'})`)
+} else {
+  Logger.warn('🔴 Redis: No valid URL provided. Using in-memory PubSub (subscriptions will not work across instances).')
+}
+
 const dateReviver = (_key: unknown, value: string | Date): Date => {
   const isISO8601Z = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)Z$/
   if (typeof value === 'string' && isISO8601Z.test(value)) {
@@ -24,26 +31,33 @@ const dateReviver = (_key: unknown, value: string | Date): Date => {
   return new Date(value)
 }
 
-function createPubSub(): RedisPubSub | PubSub {
+function createRedisPubSub(): RedisPubSub | PubSub {
   if (!hasValidRedisUrl) {
-    Logger.warn('No valid Redis URL provided. Using in-memory PubSub (not suitable for production with multiple instances).')
+    // Fall back to in-memory PubSub when Redis is not available
     return new PubSub()
   }
 
-  Logger.verbose(`Connecting to Redis: ${REDIS_URL.replace(/:[^:@]+@/, ':****@')}`)
-
-  const options: Redis.RedisOptions = {
+  const options = {
+    // Add password if provided separately (Railway sometimes does this)
     ...(REDIS_PASSWORD && { password: REDIS_PASSWORD }),
-    ...(secure && { tls: { rejectUnauthorized: false } }),
+    // TLS settings for secure connections
+    ...(secure && {
+      tls: {
+        rejectUnauthorized: false,
+      },
+    }),
+    // Retry strategy to handle temporary connection issues
     retryStrategy: (times: number) => {
       if (times > 3) {
-        Logger.warn('Redis connection failed after 3 retries. Falling back to in-memory PubSub.')
+        Logger.error(`🔴 Redis: Failed to connect after ${times} attempts. Giving up.`)
         return null // Stop retrying
       }
-      return Math.min(times * 1000, 3000)
+      const delay = Math.min(times * 1000, 3000)
+      Logger.warn(`🔴 Redis: Connection attempt ${times} failed. Retrying in ${delay}ms...`)
+      return delay
     },
     maxRetriesPerRequest: 3,
-    lazyConnect: true,
+    lazyConnect: true, // Don't connect immediately, wait for first command
   }
 
   try {
@@ -52,10 +66,16 @@ function createPubSub(): RedisPubSub | PubSub {
 
     // Handle connection errors gracefully
     publisher.on('error', (err) => {
-      Logger.error(`Redis publisher error: ${err.message}`)
+      Logger.error(`🔴 Redis publisher error: ${err.message}`)
     })
     subscriber.on('error', (err) => {
-      Logger.error(`Redis subscriber error: ${err.message}`)
+      Logger.error(`🔴 Redis subscriber error: ${err.message}`)
+    })
+    publisher.on('connect', () => {
+      Logger.log('🔴 Redis publisher connected')
+    })
+    subscriber.on('connect', () => {
+      Logger.log('🔴 Redis subscriber connected')
     })
 
     return new RedisPubSub({
@@ -64,9 +84,10 @@ function createPubSub(): RedisPubSub | PubSub {
       reviver: dateReviver,
     })
   } catch (error) {
-    Logger.error(`Failed to create Redis PubSub: ${error}. Using in-memory fallback.`)
+    Logger.error(`🔴 Redis: Failed to create PubSub: ${error}`)
+    Logger.warn('🔴 Redis: Falling back to in-memory PubSub')
     return new PubSub()
   }
 }
 
-export const apiCorePubSub = createPubSub()
+export const apiCorePubSub = createRedisPubSub()

package/src/core/files/feature/src/lib/api-core-feature.module.ts__tmpl__

@@ -24,6 +24,9 @@ const redisPubSubProvider = {
     GraphQLModule.forRoot<ApolloDriverConfig>({
       driver: ApolloDriver,
       autoSchemaFile: join(process.cwd(), 'api-schema.graphql'),
+      csrfPrevention: {
+        requestHeaders: ['apollo-require-preflight'],
+      },
       subscriptions: {
         'graphql-ws': {
           onConnect: async (context: Context<Record<string, unknown> | undefined>) => {
@@ -57,9 +60,6 @@ const redisPubSubProvider = {
           },
         },
       },
-      csrfPrevention: {
-        requestHeaders: ['apollo-require-preflight'],
-      },
       context: ({ req, res, connectionParams }: { req: Partial<Request>; res: Response; connectionParams: ConnectionParameters }) => {
         if (connectionParams) {
           // Preserve existing req properties (user, organizationContext, etc.) while adding connection headers
@@ -69,10 +69,8 @@ const redisPubSubProvider = {
       },
       sortSchema: true,
       buildSchemaOptions: {
-        dateScalarMode: 'isoDate', // Better interoperability (ISO strings, not JS Dates)
-        numberScalarMode: 'float', // Default is fine; override to 'integer' if you hate floats
-        scalarsMap: [], // Optional for custom scalar mappings if you use them
-        skipCheck: true, // Skip extra metadata validation — speeds up build
+        dateScalarMode: 'timestamp',
+        numberScalarMode: 'float',
       },
     }),
   ],

package/src/core/files/models/src/lib/generate-models.ts__tmpl__

@@ -1,6 +1,6 @@
-import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'fs' // Added readdirSync, lstatSync
-import { join } from 'path'
-import { execSync } from 'child_process'
+import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { execSync } from 'node:child_process'
 import { getDMMF } from '@prisma/internals'
 
 function extractQuotedStrings(input: string): string[] {
@@ -204,6 +204,10 @@ function generateModels(models: readonly any[], enums: readonly any[]): string {
   const usesDecimal = models.some(model =>
     model.fields.some((field: { type: string }) => field.type === 'Decimal'),
   )
+  // Check if any model field uses Json
+  const usesJson = models.some(model =>
+    model.fields.some((field: { type: string }) => field.type === 'Json'),
+  )
   if (usesDecimal) {
     output += `import Decimal from 'decimal.js';\n`
     output += `import { GraphQLDecimal } from 'prisma-graphql-type-decimal';\n`
@@ -211,9 +215,12 @@ function generateModels(models: readonly any[], enums: readonly any[]): string {
   if (usesBigInt) {
     output += `import { GraphQLBigInt } from 'graphql-scalars';\n`
   }
-  // Ensure Prisma and enums are imported correctly
+  // Import JsonValue type if any model uses Json fields
+  if (usesJson) {
+    output += `import type { JsonValue } from '${prismaImportPath}';\n`
+  }
+  // Ensure enums are imported correctly
   const enumNames = enums.map(e => e.name)
-  output += `import { Prisma } from '${prismaImportPath}';\n`
   if (enumNames.length > 0) {
     output += `import { ${enumNames.join(', ')} } from './enums';\n`
   }
@@ -244,7 +251,7 @@ function generateModels(models: readonly any[], enums: readonly any[]): string {
         } else if (originalType === 'DateTime') {
           tsType = 'Date'
         } else if (originalType === 'Json') {
-          tsType = 'Prisma.JsonValue'
+          tsType = 'JsonValue'
         } else if (originalType === 'BigInt') {
           tsType = 'bigint' // Prisma uses bigint for BigInt
         } else if (originalType === 'Bytes') {
@@ -329,7 +336,9 @@ function generateEnums(enums: readonly any[]): string {
 
   if (enums.length > 0) {
     const enumNames = enums.map(e => e.name).join(', ')
-    output += `export { ${enumNames} } from '${prismaImportPath}';\n\n`
+    // Import first to make enums available in scope, then export separately
+    output += `import { ${enumNames} } from '${prismaImportPath}';\n`
+    output += `export { ${enumNames} };\n\n`
 
     enums.forEach(enumType => {
       output += `registerEnumType(${enumType.name}, { name: '${enumType.name}' });\n\n`