@nestledjs/api 0.0.1

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

@@ -0,0 +1,97 @@
+import { Injectable, OnModuleDestroy, OnModuleInit } from '@nestjs/common'
+import { Prisma, PrismaClient } from '@<%= npmScope %>/api/prisma'
+import { CorePagingInput } from './dto/core-paging.input'
+import { withOptimize } from '@prisma/extension-optimize'
+
+@Injectable()
+export class ApiCoreDataAccessService extends PrismaClient implements OnModuleInit, OnModuleDestroy {
+  constructor() {
+    const config: Prisma.PrismaClientOptions = {
+      datasources: {
+        db: { url: `${process.env['DATABASE_URL']}?connection_limit=30` },
+      },
+      log:
+        process.env['LOG_PRISMA_QUERIES'] === 'true' || process.env['COUNT_PRISMA_QUERIES'] === 'true'
+          ? [{ emit: 'event', level: 'query' }]
+          : [{ emit: 'event', level: 'warn' }],
+    }
+    super(config)
+    this.queryCount = 0
+
+    // 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')
+      }
+
+      const extendedClient = new PrismaClient(config).$extends(withOptimize({ apiKey }))
+      Object.assign(this, extendedClient)
+    }
+  }
+
+  public queryCount: number
+
+  public async onModuleDestroy(): Promise<void> {
+    await this.$disconnect()
+  }
+
+  public async onModuleInit(): Promise<void> {
+    await this.$connect()
+
+    if (process.env['LOG_PRISMA_QUERIES'] == 'true') {
+     this.$on('query' as never, async (e: Prisma.QueryEvent) => {
+       console.log(`QUERY: ${e.query} \n\nPARAMS: ${e.params}\n\n\n`)
+     })
+    }
+
+    if (process.env['COUNT_PRISMA_QUERIES'] == 'true') {
+     this.$on('query' as never, async () => {
+       this.queryCount++
+     })
+    }
+  }
+
+  filter<T extends Record<string, unknown>>(input: CorePagingInput = {}): {
+    skip: number
+    take: number
+    where?: T
+    orderBy: { [key: string]: 'asc' | 'desc' }
+  } {
+    const {
+      search = '',
+      searchFields = [],
+      take = 20,
+      skip = 0,
+      orderBy = 'id',
+      orderDirection = 'asc',
+      filters = {},
+    } = input
+
+    const trimmedSearch = search.trim()
+    const andConditions: unknown[] = []
+
+    if (Object.keys(filters).length > 0) {
+      andConditions.push(filters)
+    }
+
+    if (trimmedSearch && searchFields.length > 0) {
+      const terms = trimmedSearch.includes(' ') ? trimmedSearch.split(' ') : [trimmedSearch].filter(Boolean)
+      const searchFilters = terms.map((term) => ({
+        OR: searchFields.map((field) => ({
+          [field]: { contains: term, mode: Prisma.QueryMode.insensitive },
+        })),
+      }))
+      andConditions.push(...searchFilters)
+    }
+
+    const where = andConditions.length > 0 ? { AND: andConditions } : undefined
+
+    return {
+      skip,
+      take,
+      where: where as unknown as T, // assert type safety for the generic
+      orderBy: { [orderBy]: orderDirection },
+    }
+  }
+}

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

@@ -0,0 +1,37 @@
+import { Logger } from '@nestjs/common'
+import { RedisPubSub } from 'graphql-redis-subscriptions'
+import Redis from 'ioredis'
+
+const REDIS_URL = process.env['REDIS_TLS_URL'] ?? process.env['REDIS_URL'] ?? ''
+const secure = REDIS_URL ? /rediss:/.test(REDIS_URL) : false
+Logger.verbose(`Redis URL: ${REDIS_URL}`)
+
+if (!REDIS_URL) {
+  Logger.warn('No Redis URL provided. PubSub functionality may be limited.')
+}
+
+const options = secure
+  ? {
+      tls: {
+        rejectUnauthorized: false,
+      },
+    }
+  : {}
+
+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)) {
+    const tempDateNumber = Date.parse(value)
+    if (!isNaN(tempDateNumber)) {
+      return new Date(tempDateNumber)
+    }
+  }
+  if (typeof value !== 'string') return value
+  return new Date(value)
+}
+
+export const apiCorePubSub = new RedisPubSub({
+  publisher: new Redis(REDIS_URL ?? 'redis://localhost:6379', options),
+  subscriber: new Redis(REDIS_URL ?? 'redis://localhost:6379', options),
+  reviver: dateReviver,
+})

package/src/core/files/data-access/src/lib/dto/core-paging.input.ts__tmpl__

@@ -0,0 +1,26 @@
+import { Field, InputType } from '@nestjs/graphql'
+import { GraphQLJSONObject } from 'graphql-type-json'
+
+@InputType()
+export class CorePagingInput {
+  @Field({ nullable: true, defaultValue: 20 })
+  take?: number
+
+  @Field({ nullable: true, defaultValue: 0 })
+  skip?: number
+
+  @Field({ nullable: true })
+  search?: string
+
+  @Field(() => [String], { nullable: true })
+  searchFields?: string[]
+
+  @Field({ nullable: true })
+  orderDirection?: 'asc' | 'desc'
+
+  @Field({ nullable: true })
+  orderBy?: string
+
+  @Field(() => GraphQLJSONObject, { nullable: true })
+  filters?: Record<string, unknown>
+}

package/src/core/files/data-access/src/lib/dto/multi-select-input.ts__tmpl__

@@ -0,0 +1,7 @@
+import { Field, InputType } from '@nestjs/graphql'
+
+@InputType()
+export class MultiSelectInput {
+  @Field({ nullable: true })
+  id?: string
+}

package/src/core/files/data-access/src/lib/models/core-paging.ts__tmpl__

@@ -0,0 +1,19 @@
+import { Field, ObjectType } from '@nestjs/graphql'
+
+@ObjectType()
+export class CorePaging {
+  @Field({ nullable: true })
+  total?: number
+
+  @Field({ nullable: true })
+  count?: number
+
+  @Field({ nullable: true })
+  take?: number
+
+  @Field({ nullable: true })
+  page?: number
+
+  @Field({ nullable: true })
+  skip?: number
+}

package/src/core/files/feature/src/index.ts__tmpl__

@@ -0,0 +1,2 @@
+export * from './lib/api-core-feature.module'
+export * from './lib/api-core-feature.service'

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

@@ -0,0 +1,12 @@
+import { Controller, Get } from '@nestjs/common'
+import { ApiCoreFeatureService } from './api-core-feature.service'
+
+@Controller()
+export class ApiCoreFeatureController {
+  constructor(private readonly service: ApiCoreFeatureService) {}
+
+  @Get('uptime')
+  uptime() {
+    return this.service.uptime()
+  }
+}

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

@@ -0,0 +1,86 @@
+import { ApolloDriver, ApolloDriverConfig } from '@nestjs/apollo'
+import { Module } from '@nestjs/common'
+import { ConfigModule } from '@nestjs/config'
+import { GraphQLModule } from '@nestjs/graphql'
+import { join } from 'path'
+import { Request, Response } from 'express'
+import { apiCorePubSub } from '@<%= npmScope %>/api/core/data-access'
+import { configuration, validationSchema } from '@<%= npmScope %>/api/config'
+import { Context } from 'graphql-ws'
+import { ApiCoreFeatureController } from './api-core-feature.controller'
+import { ApiCoreFeatureResolver } from './api-core-feature.resolver'
+import { ApiCoreFeatureService } from './api-core-feature.service'
+import { ComplexityPlugin } from './plugins/complexity.plugin'
+
+interface ConnectionParameters {
+  headers?: Record<string, string>
+}
+
+const redisPubSubProvider = {
+  provide: 'REDIS_PUB_SUB',
+  useValue: apiCorePubSub,
+}
+
+@Module({
+  imports: [
+    ConfigModule.forRoot({
+      isGlobal: true,
+      load: [configuration],
+      validationSchema,
+    }),
+    GraphQLModule.forRoot<ApolloDriverConfig>({
+      driver: ApolloDriver,
+      autoSchemaFile: join(process.cwd(), 'api-schema.graphql'),
+      subscriptions: {
+        'graphql-ws': {
+          onConnect: async (context: Context<Record<string, unknown> | undefined>) => {
+            const { extra } = context
+            if (extra && typeof extra === 'object' && 'request' in extra && extra.request && typeof extra.request === 'object' && 'rawHeaders' in extra.request) {
+              const rawHeaders = extra.request.rawHeaders as string[] | undefined
+              let token = ''
+              if (rawHeaders) {
+                for (let i = 0; i < rawHeaders.length; i += 2) {
+                  if (rawHeaders[i].toLowerCase() === 'cookie') {
+                    const cookies = rawHeaders[i + 1].split(';')
+                    for (const cookie of cookies) {
+                      const [name, value] = cookie.trim().split('=')
+                      if (name === '__session') {
+                        token = value
+                        break
+                      }
+                    }
+                    break
+                  }
+                }
+              }
+
+              if (token === '') {
+                throw new Error('Authentication token is missing')
+              }
+            } else {
+              throw new Error('Authentication token is missing')
+            }
+            return true;
+          },
+        },
+      },
+      context: ({ req, res, connectionParams }: { req: Partial<Request>; res: Response; connectionParams: ConnectionParameters }) => {
+        if (connectionParams) {
+          req = { headers: connectionParams.headers }
+        }
+        return { req, res }
+      },
+      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
+      },
+    }),
+  ],
+  controllers: [ApiCoreFeatureController],
+  providers: [ApiCoreFeatureResolver, ApiCoreFeatureService, ComplexityPlugin, redisPubSubProvider],
+  exports: [ApiCoreFeatureService, ComplexityPlugin, 'REDIS_PUB_SUB'],
+})
+export class ApiCoreFeatureModule {}

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

@@ -0,0 +1,12 @@
+import { Float, Query, Resolver } from '@nestjs/graphql'
+import { ApiCoreFeatureService } from './api-core-feature.service'
+
+@Resolver()
+export class ApiCoreFeatureResolver {
+  constructor(private readonly service: ApiCoreFeatureService) {}
+
+  @Query(() => Float, { nullable: true })
+  uptime() {
+    return this.service.uptime()
+  }
+}

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

@@ -0,0 +1,55 @@
+import { Injectable } from '@nestjs/common'
+import { ConfigService } from '@nestjs/config'
+import { CookieOptions } from 'express'
+
+@Injectable()
+export class ApiCoreFeatureService {
+  constructor(public readonly config: ConfigService) {}
+
+  uptime(): number {
+    return process.uptime()
+  }
+
+  get apiUrl(): string {
+    return this.config.getOrThrow<string>('apiUrl')
+  }
+
+  get apiCorsOrigins(): string[] {
+    return this.config.get<string[]>('api.cors.origin') ?? []
+  }
+
+  get cookie(): { name: string; options: CookieOptions } {
+    return this.config.getOrThrow<{ name: string; options: CookieOptions }>('api.cookie')
+  }
+
+  get appEmail(): string {
+    return this.config.getOrThrow<string>('app.email')
+  }
+
+  get appSupportEmail(): string {
+    return this.config.getOrThrow<string>('app.supportEmail')
+  }
+
+  get appAdminEmails(): string {
+    return this.config.getOrThrow<string>('app.adminEmails')
+  }
+
+  get appName(): string {
+    return this.config.getOrThrow<string>('app.name')
+  }
+
+  get siteUrl(): string {
+    return this.config.getOrThrow<string>('siteUrl')
+  }
+
+  get mailerConfig() {
+    return {
+      host: this.config.getOrThrow<string>('smtp.host'),
+      port: this.config.getOrThrow<string>('smtp.port'),
+      auth: {
+        user: this.config.getOrThrow<string>('smtp.user'),
+        pass: this.config.getOrThrow<string>('smtp.pass'),
+      },
+    }
+  }
+}

package/src/core/files/feature/src/lib/config/configuration.ts__tmpl__

@@ -0,0 +1,32 @@
+export const configuration = () => ({
+  prefix: 'api',
+  environment: process.env['NODE_ENV'],
+  host: process.env['HOST'],
+  port: parseInt(process.env['PORT'] ?? '3000', 10),
+  apiUrl: process.env['API_URL'],
+  api: {
+    cookie: {
+      name: process.env['API_COOKIE_NAME'],
+      options: {
+        domain: process.env['API_COOKIE_DOMAIN'],
+        httpOnly: true,
+      },
+    },
+    cors: {
+      origin: [process.env['WEB_URL']],
+    },
+  },
+  siteUrl: process.env['SITE_URL'] || process.env['API_URL']?.replace('/api', ''),
+  app: {
+    email: process.env['APP_EMAIL'],
+    supportEmail: process.env['APP_SUPPORT_EMAIL'],
+    adminEmails: process.env['APP_ADMIN_EMAILS'],
+    name: process.env['APP_NAME'],
+  },
+  smtp: {
+    host: process.env['SMTP_HOST'],
+    port: process.env['SMTP_PORT'],
+    user: process.env['SMTP_USER'],
+    pass: process.env['SMTP_PASS'],
+  },
+})

package/src/core/files/feature/src/lib/config/validation.ts__tmpl__

@@ -0,0 +1,25 @@
+import * as Joi from 'joi'
+
+export const validationSchema = Joi.object({
+  NODE_ENV: Joi.string().valid('development', 'production', 'test'),
+  HOST: Joi.string().alphanum().default('localhost'),
+  PORT: Joi.number().default(3000),
+  WEB_PORT: Joi.number().default(4200),
+  WEB_URL: Joi.string().default(
+    `http://${process.env['HOST'] || 'localhost'}:${process.env['WEB_PORT']}`
+  ),
+  API_COOKIE_DOMAIN: Joi.string().default('localhost'),
+  API_COOKIE_NAME: Joi.string().default('__session'),
+  API_URL: Joi.string().default(
+    `http://${process.env['HOST'] || 'localhost'}:${process.env['PORT']}/api`
+  ),
+  APP_NAME: Joi.string().required(),
+  APP_EMAIL: Joi.string().email().required(),
+  APP_SUPPORT_EMAIL: Joi.string().email().required(),
+  APP_ADMIN_EMAILS: Joi.string().required(),
+  SITE_URL: Joi.string().uri().required(),
+  SMTP_HOST: Joi.string().required(),
+  SMTP_PORT: Joi.string().required(),
+  SMTP_USER: Joi.string().required(),
+  SMTP_PASS: Joi.string().required(),
+})

package/src/core/files/feature/src/lib/plugins/complexity.plugin.ts__tmpl__

@@ -0,0 +1,51 @@
+import { GraphQLSchemaHost } from '@nestjs/graphql'
+import { Plugin } from '@nestjs/apollo'
+import { ApolloServerPlugin, GraphQLRequestListener } from '@apollo/server'
+import { GraphQLError } from 'graphql'
+import { fieldExtensionsEstimator, getComplexity, simpleEstimator } from 'graphql-query-complexity'
+import { Logger } from '@nestjs/common'
+
+@Plugin()
+export class ComplexityPlugin implements ApolloServerPlugin {
+  constructor(private gqlSchemaHost: GraphQLSchemaHost) {}
+
+  async requestDidStart(): Promise<void | GraphQLRequestListener<any>> {
+    const maxComplexity = process.env['QUERY_COMPLEXITY_LIMIT'] ? parseInt(process.env['QUERY_COMPLEXITY_LIMIT']) : 15000
+    const logQueryComplexity = process.env['LOG_QUERY_COMPLEXITY'] ? process.env['LOG_QUERY_COMPLEXITY'] === 'true' : false
+    const logQueryComplexityThreshold = process.env['LOG_QUERY_COMPLEXITY_THRESHOLD']
+      ? parseInt(process.env['LOG_QUERY_COMPLEXITY_THRESHOLD'])
+      : 5000
+    const queryComplexityVerboseErrors = process.env['QUERY_COMPLEXITY_VERBOSE_ERRORS']
+      ? process.env['QUERY_COMPLEXITY_VERBOSE_ERRORS'] === 'true'
+      : false
+
+    const { schema } = this.gqlSchemaHost
+
+    return {
+      didResolveOperation: async ({ request, document }): Promise<void> => {
+        const complexity = getComplexity({
+          schema,
+          operationName: request.operationName,
+          query: document,
+          variables: request.variables,
+          estimators: [fieldExtensionsEstimator(), simpleEstimator({ defaultComplexity: 1 })],
+        })
+
+        if (logQueryComplexity && complexity > logQueryComplexityThreshold) {
+          Logger.log(`Query Complexity for "${request.operationName}": ${complexity}`)
+        }
+
+        if (complexity > maxComplexity) {
+          let message = `Query "${request.operationName}" is too complex: ${complexity}. Maximum allowed complexity: ${maxComplexity}.`
+          if (queryComplexityVerboseErrors) {
+            message = `${message}\n\nVariables:\n${JSON.stringify(request.variables)}\n\nFull Query:\n${request.query}`
+          }
+          Logger.error(message)
+          throw new GraphQLError(message)
+        }
+
+        return Promise.resolve()
+      },
+    }
+  }
+}

package/src/core/files/feature/src/lib/plugins/logging.plugin.ts__tmpl__

@@ -0,0 +1,17 @@
+import { Plugin } from '@nestjs/apollo'
+import { ApolloServerPlugin, GraphQLRequestListener } from '@apollo/server'
+
+/**
+ * This is a general logging plugin that is a placeholder for future plugin use.
+ */
+@Plugin()
+export class LoggingPlugin implements ApolloServerPlugin {
+  async requestDidStart(): Promise<GraphQLRequestListener<any>> {
+    console.log('Request started')
+    return {
+      async willSendResponse(): Promise<void> {
+        console.log('Will send response')
+      },
+    }
+  }
+}

package/src/core/files/models/src/index.ts__tmpl__

@@ -0,0 +1 @@
+export * from './lib/models'