@nestledjs/api 0.0.1

package/src/app/files/src/app.config.ts__tmpl__

@@ -0,0 +1,66 @@
+import { registerAs } from '@nestjs/config'
+import Joi from 'joi'
+
+export const appConfig = registerAs('app', () => ({
+  prefix: 'api',
+  environment: process.env.NODE_ENV,
+  host: process.env.HOST,
+  port: process.env.PORT ? parseInt(process.env.PORT, 10) : 3000,
+  apiUrl: process.env.API_URL,
+  webPort: process.env.WEB_PORT ? parseInt(process.env.WEB_PORT, 10) : 4200,
+  api: {
+    cookie: {
+      name: process.env.API_COOKIE_NAME,
+      secret: process.env.API_COOKIE_SECRET,
+      options: {
+        domain: process.env.API_COOKIE_DOMAIN,
+        httpOnly: true,
+        secure: true,
+        sameSite: 'none',
+        path: '/',
+      },
+    },
+    cors: {
+      origin: [process.env.SITE_URL],
+    },
+  },
+  siteUrl: process.env.SITE_URL || (process.env.API_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 ? parseInt(process.env.SMTP_PORT, 10) : 587,
+    user: process.env.SMTP_USER,
+    pass: process.env.SMTP_PASS,
+    ignoreTLS: true,
+  },
+  twilio: {
+    accountSid: process.env.TWILIO_ACCOUNT_SID,
+    authToken: process.env.TWILIO_AUTH_TOKEN,
+    fromNumber: process.env.TWILIO_FROM_NUMBER,
+  },
+}))
+
+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/app/files/src/app.module.ts__tmpl__

@@ -0,0 +1,43 @@
+import { MiddlewareConsumer, Module, NestModule, RequestMethod } from '@nestjs/common'
+import { LoggerMiddleware } from './applogger.middleware'
+import { ConfigModule } from '@nestjs/config'
+import { appConfig, validationSchema } from './app.config'
+
+// Auto-generated modules with special functions
+export const coreModules = [
+  // Auto-generated modules with special functions
+]
+// Auto-generated modules for each data type/model
+export const defaultModules = [
+  // Auto-generated modules for each data type/model
+];
+// Manually maintained plugin modules (never overwritten by generator)
+export const pluginModules = [
+  // Manually maintained plugin modules (never overwritten by generator)
+];
+// Combined modules used in the app
+export const appModules = [
+  ...coreModules,
+  ...defaultModules,
+  ...pluginModules,
+];
+
+@Module({
+  imports: [
+    ConfigModule.forRoot({
+      load: [appConfig],
+      validationSchema: validationSchema,
+      validationOptions: {
+        allowUnknown: true,
+        abortEarly: false,
+      },
+      isGlobal: true,
+    }),
+    ...appModules,
+  ],
+})
+export class AppModule implements NestModule {
+  configure(consumer: MiddlewareConsumer): void {
+    consumer.apply(LoggerMiddleware)  .forRoutes({ path: '*path', method: RequestMethod.ALL })
+  }
+}

package/src/app/files/src/applogger.middleware.ts__tmpl__

@@ -0,0 +1,21 @@
+import { NextFunction, Request, Response } from 'express'
+import { Injectable, Logger, NestMiddleware } from '@nestjs/common'
+
+@Injectable()
+export class LoggerMiddleware implements NestMiddleware {
+  private readonly logger = new Logger('HTTP')
+
+  use(request: Request, response: Response, next: NextFunction): void {
+    const { ip, method, originalUrl } = request
+    const userAgent = request.get('user-agent') || ''
+
+    response.on('finish', () => {
+      const { statusCode } = response
+      const contentLength = response.get('content-length')
+
+      this.logger.log(`${method} ${originalUrl} ${statusCode} ${contentLength} - ${userAgent} ${ip}`)
+    })
+
+    next()
+  }
+}

package/src/app/files/src/main.ts__tmpl__

@@ -0,0 +1,33 @@
+import { Logger } from '@nestjs/common'
+import { NestFactory } from '@nestjs/core'
+import { ConfigService } from '@nestjs/config'
+import cookieParser from 'cookie-parser'
+
+import { AppModule } from './app.module'
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule)
+  const configService = app.get(ConfigService)
+
+  // Get individual properties with fallbacks
+  const prefix = configService.get('app.prefix') || 'api';
+  const port = configService.get('app.port') || 3000;
+  const host = configService.get('app.host') || 'localhost';
+
+  app.setGlobalPrefix(prefix)
+  app.enableCors({
+    credentials: true,
+    origin: configService.get('app.api.cors.origin') || '*',
+  })
+  app.use(cookieParser(configService.get('app.api.cookie.secret') || 'secret'));
+
+  await app.listen(port, host, () => {
+    Logger.log(`Listening at http://${host}:${port}/${prefix}`)
+    Logger.log(`Listening at http://${host}:${port}/graphql`)
+  })
+}
+
+bootstrap().catch((error) => {
+  Logger.error('Failed to start the application', error);
+  process.exit(1);
+});

package/src/app/files/webpack.config.js__tmpl__

@@ -0,0 +1,54 @@
+const path = require('path');
+const TsconfigPathsPlugin = require('tsconfig-paths-webpack-plugin');
+const nodeExternals = require('webpack-node-externals');
+
+module.exports = {
+  target: 'node',
+  mode: 'development',
+  entry: path.resolve(__dirname, 'src/main.ts'),
+  output: {
+    path: path.resolve(__dirname, '../../dist/apps/api'),
+    filename: 'main.js',
+  },
+  resolve: {
+    extensions: ['.ts', '.js'],
+    plugins: [
+      new TsconfigPathsPlugin({
+        configFile: path.resolve(__dirname, '../../tsconfig.base.json'),
+      }),
+    ],
+  },
+  module: {
+    rules: [
+      {
+        test: /\.ts$/,
+        use: 'ts-loader',
+        exclude: [
+          /node_modules/,
+          path.resolve(__dirname, '../../libs/api/prisma/src/lib/prisma-generated')
+        ],
+      },
+
+    ],
+  },
+  externals: [
+    nodeExternals({
+      allowlist: [
+        /^@<%= npmScope %>\/api/, // allow your own libs
+      ],
+      // Manually exclude Prisma internals if needed
+      function ({ request }, callback) {
+        if (request && request.includes('@prisma/client')) {
+          return callback(null, 'commonjs @prisma/client')
+        }
+        if (request && request.includes('.prisma/client')) {
+          return callback(null, 'commonjs .prisma/client')
+        }
+        if (request && request === '@<%= npmScope %>/api/prisma') {
+          return callback(null, 'commonjs @<%= npmScope %>/api/prisma')
+        }
+        callback()
+      }
+    })
+  ]
+};

package/src/app/generator.spec.ts

@@ -0,0 +1,112 @@
+import { createTreeWithEmptyWorkspace } from '@nx/devkit/testing'
+import { Tree } from '@nx/devkit'
+import { execSync } from 'child_process'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import generator from './generator'
+
+vi.mock('child_process', async (importOriginal) => {
+  const originalModule = await importOriginal()
+  return {
+    ...(originalModule as object),
+    execSync: vi.fn(),
+  }
+})
+
+describe('api generator', () => {
+  let tree: Tree
+  const mockedExecSync = execSync as ReturnType<(typeof vi)['fn']>
+
+  beforeEach(() => {
+    tree = createTreeWithEmptyWorkspace()
+    tree.write('package.json', JSON.stringify({ name: 'test-repo', scripts: {} }))
+
+    mockedExecSync.mockImplementation((command: string) => {
+      if (command.startsWith('nx g @nx/nest:application')) {
+        tree.write(
+          'apps/api/webpack.config.js',
+          `
+const path = require('path');
+const { composePlugins, withNx } = require('@nx/webpack');
+
+module.exports = composePlugins(withNx(), (config) => {
+  return {
+    ...config,
+    output: {
+      ...config.output,
+      devtoolModuleFilenameTemplate: (info) => {
+        const rel = path.relative(process.cwd(), info.absoluteResourcePath);
+        return \`webpack://\${rel}\`;
+      },
+    },
+    assets: ['./src/assets'],
+    generatePackageJson: true,
+  };
+});`
+        )
+        // Add a mock tsconfig.app.json file with the compiler options we want to remove
+        tree.write('apps/api/tsconfig.app.json', JSON.stringify({
+          extends: '../../tsconfig.base.json',
+          compilerOptions: {
+            module: 'commonjs',
+            moduleResolution: 'node',
+            emitDecoratorMetadata: true,
+            experimentalDecorators: true,
+            outDir: '../../dist/out-tsc',
+            declaration: true,
+            types: ['node']
+          },
+          exclude: ['jest.config.ts', '**/*.spec.ts', '**/*.test.ts'],
+          include: ['**/*.ts']
+        }, null, 2))
+        tree.write('apps/api/src/app/.gitkeep', '')
+        tree.write('apps/api/src/assets/.gitkeep', '')
+      }
+      return ''
+    })
+
+    vi.spyOn(console, 'log').mockImplementation(() => { /* empty */ })
+    vi.spyOn(console, 'warn').mockImplementation(() => { /* empty */ })
+    vi.spyOn(console, 'error').mockImplementation(() => { /* empty */ })
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+    mockedExecSync.mockClear()
+  })
+
+  it('should run successfully', async () => {
+    await generator(tree, {})
+
+    expect(mockedExecSync).toHaveBeenCalledWith(
+      'nx g @nx/nest:application --name api --directory apps/api --no-interactive',
+      {
+        stdio: 'inherit',
+        cwd: tree.root,
+      }
+    )
+
+    const webpackConfig = tree.read('apps/api/webpack.config.js', 'utf-8')
+    expect(webpackConfig).not.toContain("assets: ['./src/assets']")
+
+    const packageJson = JSON.parse(tree.read('package.json', 'utf-8'))
+    expect(packageJson.scripts['dev:api']).toBe('nx serve api --skip-nx-cache')
+
+    expect(tree.exists('apps/api/src/app')).toBe(false)
+    expect(tree.exists('apps/api/src/assets')).toBe(false)
+
+    expect(tree.exists('apps/api/src/app.config.ts')).toBe(true)
+    expect(tree.exists('apps/api/src/app.module.ts')).toBe(true)
+    expect(tree.exists('apps/api/src/applogger.middleware.ts')).toBe(true)
+    expect(tree.exists('apps/api/src/main.ts')).toBe(true)
+
+    // Verify that the compiler options are removed from tsconfig.app.json
+    const tsConfig = JSON.parse(tree.read('apps/api/tsconfig.app.json', 'utf-8'))
+    expect(tsConfig.compilerOptions.module).toBeUndefined()
+    expect(tsConfig.compilerOptions.moduleResolution).toBeUndefined()
+    expect(tsConfig.compilerOptions.emitDecoratorMetadata).toBeUndefined()
+    expect(tsConfig.compilerOptions.experimentalDecorators).toBeUndefined()
+    // Verify that other compiler options are preserved
+    expect(tsConfig.compilerOptions.outDir).toBe('../../dist/out-tsc')
+    expect(tsConfig.compilerOptions.declaration).toBe(true)
+  })
+})

package/src/app/generator.ts

@@ -0,0 +1,105 @@
+import { generateFiles, joinPathFragments, Tree, updateJson } from '@nx/devkit'
+import { execSync } from 'child_process'
+import * as path from 'path'
+import { getNpmScope } from '@nx/js/src/utils/package-json/get-npm-scope'
+
+/**
+ * Removes specific compiler options from tsconfig.app.json to use the settings from tsconfig.base.json
+ * @param tree The file system tree
+ */
+function updateAppTsConfig(tree: Tree): void {
+  const tsConfigPath = 'apps/api/tsconfig.app.json'
+  if (tree.exists(tsConfigPath)) {
+    updateJson(tree, tsConfigPath, (json) => {
+      if (json.compilerOptions) {
+        // Remove specific options to use the ones from tsconfig.base.json
+        delete json.compilerOptions.module
+        delete json.compilerOptions.moduleResolution
+        delete json.compilerOptions.emitDecoratorMetadata
+        delete json.compilerOptions.experimentalDecorators
+      }
+      return json
+    })
+  } else {
+    console.warn(`tsconfig.app.json not found at: ${tsConfigPath}`)
+  }
+}
+
+interface Schema {
+  [key: string]: unknown
+}
+
+export default async function (tree: Tree, schema: Schema) {
+  try {
+    // Get the workspace root directory
+    const workspaceRoot = tree.root
+
+    // Create apps directory if it doesn't exist
+    if (!tree.exists('apps')) {
+      tree.write('apps/.gitkeep', '')
+    }
+
+    // Run the Nx generator command directly from the workspace root with proper workspace layout
+    execSync('nx g @nx/nest:application --name api --directory apps/api --no-interactive', {
+      stdio: 'inherit',
+      cwd: workspaceRoot,
+    })
+
+    // Wait a bit for files to be created
+    await new Promise((resolve) => setTimeout(resolve, 2000))
+
+    // Update tsconfig.app.json to remove specific compiler options
+    updateAppTsConfig(tree)
+
+    // Generate all files according to the template folder structure
+    generateFiles(
+      tree,
+      joinPathFragments(__dirname, './files'),
+      path.join('apps', 'api'),
+      { ...schema, tmpl: '', npmScope: getNpmScope(tree) }
+    );
+
+    // Add dev:api script to package.json
+    updateJson(tree, 'package.json', (json) => {
+      if (!json.scripts) {
+        json.scripts = {}
+      }
+      json.scripts['dev:api'] = 'nx serve api --skip-nx-cache'
+      return json
+    })
+
+    // Update the build target in apps/api/project.json to use custom webpack command
+    const projectJsonPath = path.join('apps', 'api', 'project.json')
+    if (tree.exists(projectJsonPath)) {
+      updateJson(tree, projectJsonPath, (json) => {
+        json.targets = json.targets || {}
+        json.targets.build = {
+          executor: 'nx:run-commands',
+          options: {
+            command: 'NODE_ENV=production webpack-cli --config apps/api/webpack.config.js',
+          },
+          configurations: {
+            development: {
+              command: 'NODE_ENV=development webpack-cli --config apps/api/webpack.config.js',
+            },
+          },
+        }
+        return json
+      })
+    } else {
+      console.warn(`project.json not found at: ${projectJsonPath}`)
+    }
+
+    // Optionally, delete the unused default app files if they exist
+    const targetPath = path.join('apps', 'api', 'src')
+    const filesToDelete = [path.join(targetPath, 'assets'), path.join(targetPath, 'app')]
+    filesToDelete.forEach((filePath) => {
+      if (tree.exists(filePath)) {
+        tree.delete(filePath)
+      }
+    })
+  } catch (error) {
+    console.error('Error generating API app:', error)
+    throw error
+  }
+}

package/src/app/schema.d.ts

@@ -0,0 +1 @@
+export type AppSetupGeneratorSchema = Record<string, unknown>

package/src/app/schema.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "cli": "nx",
+  "$id": "ApiGenerator",
+  "title": "API Application Generator",
+  "type": "object",
+  "properties": {},
+  "required": []
+}

package/src/config/files/src/index.ts__tmpl__

@@ -0,0 +1,3 @@
+export * from './lib/config.service'
+export * from './lib/configuration'
+export * from './lib/validation'

package/src/config/files/src/lib/config.service.ts__tmpl__

@@ -0,0 +1,51 @@
+import { Injectable } from '@nestjs/common'
+import { ConfigService } from '@nestjs/config'
+import { CookieOptions } from 'express'
+
+@Injectable()
+export class ApiConfigService {
+  constructor(public readonly config: ConfigService) {}
+
+  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/config/files/src/lib/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/config/files/src/lib/validation.ts__tmpl__

@@ -0,0 +1,21 @@
+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/config/generator.spec.ts

@@ -0,0 +1,47 @@
+import { formatFiles, installPackagesTask, Tree } from '@nx/devkit'
+import { createTreeWithEmptyWorkspace } from '@nx/devkit/testing'
+import { describe, expect, it, vi } from 'vitest'
+import { apiLibraryGenerator } from '@nestledjs/utils'
+
+import generator from './generator'
+
+vi.mock('@nestledjs/utils', async () => {
+  const actual = await vi.importActual('@nestledjs/utils')
+  return {
+    ...actual,
+    apiLibraryGenerator: vi.fn(),
+  }
+})
+
+vi.mock('@nx/devkit', async () => {
+  const actual = await vi.importActual('@nx/devkit')
+  return {
+    ...actual,
+    formatFiles: vi.fn(),
+    installPackagesTask: vi.fn(),
+  }
+})
+
+describe('config generator', () => {
+  let tree: Tree
+
+  beforeEach(() => {
+    tree = createTreeWithEmptyWorkspace()
+  })
+
+  it('should run successfully', async () => {
+    const callback = await generator(tree)
+    callback()
+
+    expect(apiLibraryGenerator).toHaveBeenCalledWith(tree, { name: 'config', overwrite: false }, expect.any(String))
+    expect(formatFiles).toHaveBeenCalledWith(tree)
+    expect(installPackagesTask).toHaveBeenCalledWith(tree)
+  })
+
+  it('should pass overwrite flag to apiLibraryGenerator when overwrite is true', async () => {
+    const callback = await generator(tree, { overwrite: true })
+    callback()
+
+    expect(apiLibraryGenerator).toHaveBeenCalledWith(tree, { name: 'config', overwrite: true }, expect.any(String))
+  })
+})

package/src/config/generator.ts

@@ -0,0 +1,16 @@
+import { formatFiles, installPackagesTask, joinPathFragments, Tree } from '@nx/devkit'
+import { apiLibraryGenerator } from '@nestledjs/utils'
+import { ApiConfigGeneratorSchema } from './schema'
+
+export default async function generateLibraries(tree: Tree, options: ApiConfigGeneratorSchema = {}) {
+  const templateRootPath = joinPathFragments(__dirname, './files')
+  const overwrite = options.overwrite === true
+
+  await apiLibraryGenerator(tree, { name: 'config', overwrite }, templateRootPath)
+
+  await formatFiles(tree)
+
+  return () => {
+    installPackagesTask(tree)
+  }
+}

package/src/config/schema.d.ts

@@ -0,0 +1,3 @@
+export interface ApiConfigGeneratorSchema {
+  overwrite?: boolean
+}

package/src/config/schema.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "ApiConfig",
+  "title": "Create the API Config library",
+  "type": "object",
+  "properties": {
+    "overwrite": {
+      "type": "boolean",
+      "description": "Whether to overwrite the existing config library if it exists.",
+      "default": false
+    }
+  }
+}

package/src/core/files/data-access/src/index.ts__tmpl__

@@ -0,0 +1,5 @@
+export * from './lib/api-core-data-access.service'
+export * from './lib/api-core-data-access.module'
+export * from './lib/api-core-pub-sub'
+export * from './lib/models/core-paging'
+export * from './lib/dto/core-paging.input'

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

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common'
+
+import { ApiCoreDataAccessService } from './api-core-data-access.service'
+
+@Module({
+  providers: [ApiCoreDataAccessService],
+  exports: [ApiCoreDataAccessService],
+})
+export class ApiCoreDataAccessModule {}