@dismissible/nestjs-api 0.0.2-canary.8976e84.0

package/config/.env.yaml

@@ -0,0 +1,8 @@
+server:
+  port: ${DISMISSIBLE_PORT:-3001}
+
+swagger:
+  enabled: ${DISMISSIBLE_SWAGGER_ENABLED:-true}
+
+db:
+  connectionString: ${DISMISSIBLE_POSTGRES_STORAGE_CONNECTION_STRING:-'postgresql://postgres:postgres@localhost:5432/dismissible'}

package/jest.config.ts

@@ -0,0 +1,13 @@
+export default {
+  displayName: 'api',
+  preset: '../jest.preset.js',
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.json' }],
+  },
+  moduleFileExtensions: ['ts', 'js', 'html'],
+  coverageDirectory: '../coverage/api',
+  testMatch: ['**/*.spec.ts'],
+  testPathIgnorePatterns: ['\\.e2e-spec\\.ts$'],
+  transformIgnorePatterns: ['node_modules/(?!(nest-typed-config|uuid)/)'],
+};

package/jest.e2e-config.ts

@@ -0,0 +1,12 @@
+export default {
+  displayName: 'api-e2e',
+  preset: '../jest.preset.js',
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.json' }],
+  },
+  moduleFileExtensions: ['ts', 'js', 'html'],
+  coverageDirectory: '../coverage/api-e2e',
+  testMatch: ['**/*.e2e-spec.ts'],
+  transformIgnorePatterns: ['node_modules/(?!(nest-typed-config|uuid)/)'],
+};

package/nest-cli.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://json.schemastore.org/nest-cli",
+  "collection": "@nestjs/schematics",
+  "sourceRoot": "src",
+  "compilerOptions": {
+    "deleteOutDir": true,
+    "tsConfigPath": "tsconfig.app.json",
+    "assets": [
+      {
+        "include": "../config/**/*.yaml",
+        "outDir": "../dist/api/config",
+        "watchAssets": true
+      }
+    ]
+  }
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@dismissible/nestjs-api",
+  "version": "0.0.2-canary.8976e84.0",
+  "description": "Dismissible API application",
+  "main": "./src/main.js",
+  "types": "./src/main.d.ts",
+  "exports": {
+    ".": {
+      "import": "./src/main.mjs",
+      "require": "./src/main.js",
+      "types": "./src/main.d.ts"
+    }
+  },
+  "bin": {
+    "dismissible-api": "./src/main.js"
+  },
+  "scripts": {
+    "start": "node src/main.js"
+  },
+  "dependencies": {
+    "@dismissible/nestjs-dismissible": "^0.0.2-canary.8976e84.0",
+    "@dismissible/nestjs-dismissible-item": "^0.0.2-canary.8976e84.0",
+    "@dismissible/nestjs-storage": "^0.0.2-canary.8976e84.0",
+    "@dismissible/nestjs-postgres-storage": "^0.0.2-canary.8976e84.0",
+    "@dismissible/nestjs-logger": "^0.0.2-canary.8976e84.0",
+    "@nestjs/common": "^11.1.9",
+    "@nestjs/core": "^11.1.9",
+    "@nestjs/platform-express": "^11.1.9",
+    "@nestjs/swagger": "^11.0.0",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.1",
+    "nest-typed-config": "^2.0.0",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.2"
+  },
+  "keywords": [
+    "nestjs",
+    "api"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/DismissibleIo/dismissible-api"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/project.json

@@ -0,0 +1,91 @@
+{
+  "name": "api",
+  "$schema": "../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "api/src",
+  "projectType": "application",
+  "tags": [],
+  "targets": {
+    "build": {
+      "executor": "@nx/js:tsc",
+      "outputs": ["{options.outputPath}"],
+      "dependsOn": ["^build"],
+      "options": {
+        "outputPath": "dist/api",
+        "main": "api/src/main.ts",
+        "tsConfig": "api/tsconfig.app.json",
+        "assets": [
+          {
+            "input": "api/config",
+            "glob": "**/*.yaml",
+            "output": "config"
+          }
+        ],
+        "generatePackageJson": true
+      }
+    },
+    "serve": {
+      "executor": "@nx/js:node",
+      "options": {
+        "buildTarget": "api:build",
+        "runBuildTargetDependencies": true,
+        "watch": true
+      },
+      "configurations": {
+        "development": {
+          "buildTarget": "api:build"
+        },
+        "production": {
+          "buildTarget": "api:build"
+        }
+      },
+      "defaultConfiguration": "development"
+    },
+    "lint": {
+      "executor": "@nx/eslint:lint",
+      "outputs": ["{options.outputFile}"],
+      "options": {
+        "lintFilePatterns": ["api/**/*.ts"]
+      }
+    },
+    "test": {
+      "executor": "@nx/jest:jest",
+      "outputs": ["{workspaceRoot}/coverage/api"],
+      "options": {
+        "jestConfig": "api/jest.config.ts",
+        "passWithNoTests": true
+      }
+    },
+    "test-e2e": {
+      "executor": "@nx/jest:jest",
+      "outputs": ["{workspaceRoot}/coverage/api-e2e"],
+      "options": {
+        "jestConfig": "api/jest.e2e-config.ts"
+      }
+    },
+    "prisma:generate": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "npx prisma generate --schema=libs/postgres-storage/prisma/schema.prisma"
+      }
+    },
+    "prisma:migrate": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "npx prisma migrate dev --schema=libs/postgres-storage/prisma/schema.prisma"
+      }
+    },
+    "prisma:push": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "npx prisma db push --schema=libs/postgres-storage/prisma/schema.prisma"
+      }
+    },
+    "npm-publish": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "npm publish --access public",
+        "cwd": "dist/api"
+      }
+    }
+  }
+}

package/src/app-test.factory.ts

@@ -0,0 +1,32 @@
+import { Test, TestingModuleBuilder } from '@nestjs/testing';
+import { INestApplication } from '@nestjs/common';
+import { AppModule, AppModuleOptions } from './app.module';
+import { configureApp } from './app.setup';
+import { PrismaService } from '@dismissible/nestjs-postgres-storage';
+
+export type TestAppOptions = {
+  moduleOptions?: AppModuleOptions;
+  customize?: (builder: TestingModuleBuilder) => TestingModuleBuilder;
+};
+
+export async function createTestApp(options?: TestAppOptions): Promise<INestApplication> {
+  let builder = Test.createTestingModule({
+    imports: [AppModule.forRoot(options?.moduleOptions)],
+  });
+
+  if (options?.customize) {
+    builder = options.customize(builder);
+  }
+
+  const moduleFixture = await builder.compile();
+  const app = moduleFixture.createNestApplication();
+  await configureApp(app);
+  await app.init();
+
+  return app;
+}
+
+export async function cleanupTestData(app: INestApplication): Promise<void> {
+  const prisma = app.get(PrismaService);
+  await prisma.dismissibleItem.deleteMany({});
+}

package/src/app.e2e-spec.ts

@@ -0,0 +1,221 @@
+import { INestApplication } from '@nestjs/common';
+import request from 'supertest';
+import { join } from 'path';
+import { createTestApp, cleanupTestData } from './app-test.factory';
+
+describe('Dismissible API (e2e)', () => {
+  let app: INestApplication;
+
+  beforeAll(async () => {
+    app = await createTestApp({
+      moduleOptions: {
+        configPath: join(__dirname, '../config'),
+      },
+    });
+    await cleanupTestData(app);
+  });
+
+  afterAll(async () => {
+    await app.close();
+    await cleanupTestData(app);
+  });
+
+  describe('GET /v1/user/:userId/dismissible-item/:id (get-or-create)', () => {
+    it('should create a new item on first request', async () => {
+      const response = await request(app.getHttpServer())
+        .get('/v1/user/user-123/dismissible-item/test-banner-1')
+        .expect(200);
+
+      expect(response.body.data).toBeDefined();
+      expect(response.body.data.itemId).toBe('test-banner-1');
+      expect(response.body.data.userId).toBe('user-123');
+      expect(response.body.data.createdAt).toBeDefined();
+      expect(response.body.data.dismissedAt).toBeUndefined();
+    });
+
+    it('should return existing item on subsequent requests', async () => {
+      // First request - creates the item
+      const firstResponse = await request(app.getHttpServer())
+        .get('/v1/user/user-456/dismissible-item/test-banner-2')
+        .expect(200);
+
+      const createdAt = firstResponse.body.data.createdAt;
+
+      // Second request - returns existing item
+      const secondResponse = await request(app.getHttpServer())
+        .get('/v1/user/user-456/dismissible-item/test-banner-2')
+        .expect(200);
+
+      expect(secondResponse.body.data.itemId).toBe('test-banner-2');
+      expect(secondResponse.body.data.createdAt).toBe(createdAt);
+    });
+
+    it('should store and retrieve metadata', async () => {
+      const response = await request(app.getHttpServer())
+        .get('/v1/user/user-789/dismissible-item/test-banner-metadata')
+        .query({ metadata: ['version:2', 'category:promo'] })
+        .expect(200);
+
+      expect(response.body.data.metadata).toEqual({
+        version: 2,
+        category: 'promo',
+      });
+    });
+  });
+
+  describe('DELETE /v1/user/:userId/dismissible-item/:id (dismiss)', () => {
+    it('should dismiss an existing item', async () => {
+      const userId = 'user-dismiss-1';
+      // First create the item
+      await request(app.getHttpServer())
+        .get(`/v1/user/${userId}/dismissible-item/dismiss-test-1`)
+        .expect(200);
+
+      // Then dismiss it
+      const response = await request(app.getHttpServer())
+        .delete(`/v1/user/${userId}/dismissible-item/dismiss-test-1`)
+        .expect(200);
+
+      expect(response.body.data).toBeDefined();
+      expect(response.body.data.dismissedAt).toBeDefined();
+    });
+
+    it('should return 400 when dismissing non-existent item', async () => {
+      const response = await request(app.getHttpServer())
+        .delete('/v1/user/user-123/dismissible-item/non-existent-item')
+        .expect(400);
+
+      expect(response.body.error).toBeDefined();
+      expect(response.body.error.message).toContain('not found');
+    });
+
+    it('should return 400 when dismissing already dismissed item', async () => {
+      const userId = 'user-dismiss-2';
+      // Create the item
+      await request(app.getHttpServer())
+        .get(`/v1/user/${userId}/dismissible-item/dismiss-test-2`)
+        .expect(200);
+
+      // Dismiss it first time
+      await request(app.getHttpServer())
+        .delete(`/v1/user/${userId}/dismissible-item/dismiss-test-2`)
+        .expect(200);
+
+      // Try to dismiss again
+      const response = await request(app.getHttpServer())
+        .delete(`/v1/user/${userId}/dismissible-item/dismiss-test-2`)
+        .expect(400);
+
+      expect(response.body.error).toBeDefined();
+      expect(response.body.error.message).toContain('already dismissed');
+    });
+  });
+
+  describe('POST /v1/user/:userId/dismissible-item/:id (restore)', () => {
+    it('should restore a dismissed item', async () => {
+      const userId = 'user-restore-1';
+      // Create and dismiss the item
+      await request(app.getHttpServer())
+        .get(`/v1/user/${userId}/dismissible-item/restore-test-1`)
+        .expect(200);
+
+      await request(app.getHttpServer())
+        .delete(`/v1/user/${userId}/dismissible-item/restore-test-1`)
+        .expect(200);
+
+      // Restore it
+      const response = await request(app.getHttpServer())
+        .post(`/v1/user/${userId}/dismissible-item/restore-test-1`)
+        .expect(201);
+
+      expect(response.body.data).toBeDefined();
+      expect(response.body.data.dismissedAt).toBeUndefined();
+    });
+
+    it('should return 400 when restoring non-existent item', async () => {
+      const response = await request(app.getHttpServer())
+        .post('/v1/user/user-123/dismissible-item/non-existent-restore')
+        .expect(400);
+
+      expect(response.body.error).toBeDefined();
+      expect(response.body.error.message).toContain('not found');
+    });
+
+    it('should return 400 when restoring non-dismissed item', async () => {
+      const userId = 'user-restore-2';
+      // Create item but don't dismiss it
+      await request(app.getHttpServer())
+        .get(`/v1/user/${userId}/dismissible-item/restore-test-2`)
+        .expect(200);
+
+      // Try to restore
+      const response = await request(app.getHttpServer())
+        .post(`/v1/user/${userId}/dismissible-item/restore-test-2`)
+        .expect(400);
+
+      expect(response.body.error).toBeDefined();
+      expect(response.body.error.message).toContain('not dismissed');
+    });
+  });
+
+  describe('Full lifecycle flow', () => {
+    it('should handle create -> dismiss -> restore -> dismiss cycle', async () => {
+      const userId = 'lifecycle-user';
+      const itemId = 'lifecycle-test';
+
+      // Create
+      const createResponse = await request(app.getHttpServer())
+        .get(`/v1/user/${userId}/dismissible-item/${itemId}`)
+        .expect(200);
+
+      expect(createResponse.body.data.dismissedAt).toBeUndefined();
+
+      // Dismiss
+      const dismissResponse = await request(app.getHttpServer())
+        .delete(`/v1/user/${userId}/dismissible-item/${itemId}`)
+        .expect(200);
+
+      expect(dismissResponse.body.data.dismissedAt).toBeDefined();
+
+      // Restore
+      const restoreResponse = await request(app.getHttpServer())
+        .post(`/v1/user/${userId}/dismissible-item/${itemId}`)
+        .expect(201);
+
+      expect(restoreResponse.body.data.dismissedAt).toBeUndefined();
+
+      // Dismiss again
+      const dismissAgainResponse = await request(app.getHttpServer())
+        .delete(`/v1/user/${userId}/dismissible-item/${itemId}`)
+        .expect(200);
+
+      expect(dismissAgainResponse.body.data.dismissedAt).toBeDefined();
+    });
+
+    it('should preserve metadata through dismiss and restore', async () => {
+      const userId = 'user-metadata';
+      const itemId = 'metadata-preserve-test';
+
+      // Create with metadata
+      await request(app.getHttpServer())
+        .get(`/v1/user/${userId}/dismissible-item/${itemId}`)
+        .query({ metadata: ['key:value', 'count:42'] })
+        .expect(200);
+
+      // Dismiss
+      await request(app.getHttpServer())
+        .delete(`/v1/user/${userId}/dismissible-item/${itemId}`)
+        .expect(200);
+
+      // Restore and verify metadata
+      const restoreResponse = await request(app.getHttpServer())
+        .post(`/v1/user/${userId}/dismissible-item/${itemId}`)
+        .expect(201);
+
+      expect(restoreResponse.body.data.metadata).toEqual({
+        key: 'value',
+        count: 42,
+      });
+    });
+  });
+});

package/src/app.module.ts

@@ -0,0 +1,48 @@
+import { Module, ModuleMetadata, Type } from '@nestjs/common';
+import { HealthModule } from './health';
+import { ConfigModule } from './config';
+import { AppConfig } from './config/app.config';
+import { join } from 'path';
+import { DismissibleModule } from '@dismissible/nestjs-dismissible';
+import { IDismissibleLogger } from '@dismissible/nestjs-logger';
+import { DefaultAppConfig } from './config/default-app.config';
+import { PostgresStorageConfig, PostgresStorageModule } from '@dismissible/nestjs-postgres-storage';
+
+export type AppModuleOptions = {
+  configPath?: string;
+  schema?: new () => DefaultAppConfig;
+  logger?: Type<IDismissibleLogger>;
+};
+
+@Module({})
+export class AppModule {
+  static forRoot(options?: AppModuleOptions) {
+    return {
+      module: AppModule,
+      ...this.getModuleMetadata(options),
+    };
+  }
+
+  static getModuleMetadata(options?: AppModuleOptions): ModuleMetadata {
+    return {
+      imports: [
+        ConfigModule.forRoot({
+          path: options?.configPath ?? join(__dirname, '../config'),
+          schema: options?.schema ?? AppConfig,
+        }),
+        HealthModule,
+        DismissibleModule.forRoot({
+          logger: options?.logger,
+          storage: PostgresStorageModule.forRootAsync({
+            useFactory(config: PostgresStorageConfig) {
+              return {
+                connectionString: config.connectionString,
+              };
+            },
+            inject: [PostgresStorageConfig],
+          }),
+        }),
+      ],
+    };
+  }
+}

package/src/app.setup.ts

@@ -0,0 +1,17 @@
+import { INestApplication, ValidationPipe } from '@nestjs/common';
+import { SwaggerConfig, configureAppWithSwagger } from './swagger';
+
+export async function configureApp(app: INestApplication): Promise<void> {
+  // Global validation pipe for request validation
+  app.useGlobalPipes(
+    new ValidationPipe({
+      whitelist: true,
+      forbidNonWhitelisted: true,
+      transform: true,
+      disableErrorMessages: false,
+    }),
+  );
+
+  const swaggerConfig = app.get(SwaggerConfig);
+  configureAppWithSwagger(app, swaggerConfig);
+}

package/src/bootstrap.ts

@@ -0,0 +1,24 @@
+import { NestFactory } from '@nestjs/core';
+import { AppModule } from './app.module';
+import { ServerConfig } from './server/server.config';
+import { configureApp } from './app.setup';
+import { DefaultAppConfig } from './config/default-app.config';
+import { IDismissibleLogger } from '@dismissible/nestjs-logger';
+import { Type } from '@nestjs/common';
+
+export type IBootstrapOptions = {
+  configPath?: string;
+  schema?: new () => DefaultAppConfig;
+  logger?: Type<IDismissibleLogger>;
+};
+
+export async function bootstrap(options?: IBootstrapOptions) {
+  const app = await NestFactory.create(AppModule.forRoot(options));
+
+  await configureApp(app);
+
+  const serverConfig = app.get(ServerConfig);
+  const port = serverConfig.port ?? 3000;
+  await app.listen(port);
+  console.log(`🚀 Application is running on: http://localhost:${port}`);
+}

package/src/config/app.config.ts

@@ -0,0 +1,15 @@
+import { ValidateNested } from 'class-validator';
+import { Type } from 'class-transformer';
+import { SwaggerConfig } from '../swagger';
+import { DefaultAppConfig } from './default-app.config';
+import { PostgresStorageConfig } from '@dismissible/nestjs-postgres-storage';
+
+export class AppConfig extends DefaultAppConfig {
+  @ValidateNested()
+  @Type(() => SwaggerConfig)
+  public readonly swagger!: SwaggerConfig;
+
+  @ValidateNested()
+  @Type(() => PostgresStorageConfig)
+  public readonly db!: PostgresStorageConfig;
+}

package/src/config/config.module.spec.ts

@@ -0,0 +1,96 @@
+import { ConfigModule } from './config.module';
+import { TypedConfigModule } from 'nest-typed-config';
+import { fileLoader } from 'nest-typed-config';
+
+// Mock nest-typed-config
+jest.mock('nest-typed-config', () => ({
+  TypedConfigModule: {
+    forRoot: jest.fn(),
+  },
+  fileLoader: jest.fn(),
+}));
+
+// Mock path
+jest.mock('path', () => ({
+  join: jest.fn((...args) => args.join('/')),
+}));
+
+describe('ConfigModule', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('forRoot', () => {
+    it('should return a dynamic module with default path', () => {
+      const mockSchema = class TestSchema {};
+      const mockFileLoader = jest.fn();
+      (fileLoader as jest.Mock).mockReturnValue(mockFileLoader);
+      (TypedConfigModule.forRoot as jest.Mock).mockReturnValue({});
+
+      const result = ConfigModule.forRoot({
+        schema: mockSchema,
+      });
+
+      expect(result.module).toBe(ConfigModule);
+      expect(result.exports).toContain(TypedConfigModule);
+      expect(fileLoader).toHaveBeenCalledWith({
+        searchFrom: expect.stringContaining('config'),
+        ignoreEnvironmentVariableSubstitution: false,
+      });
+      expect(TypedConfigModule.forRoot).toHaveBeenCalledWith({
+        schema: mockSchema,
+        load: [mockFileLoader],
+      });
+    });
+
+    it('should use custom path when provided', () => {
+      const mockSchema = class TestSchema {};
+      const customPath = '/custom/config/path';
+      const mockFileLoader = jest.fn();
+      (fileLoader as jest.Mock).mockReturnValue(mockFileLoader);
+      (TypedConfigModule.forRoot as jest.Mock).mockReturnValue({});
+
+      const result = ConfigModule.forRoot({
+        schema: mockSchema,
+        path: customPath,
+      });
+
+      expect(result.module).toBe(ConfigModule);
+      expect(fileLoader).toHaveBeenCalledWith({
+        searchFrom: customPath,
+        ignoreEnvironmentVariableSubstitution: false,
+      });
+    });
+
+    it('should respect ignoreEnvironmentVariableSubstitution option', () => {
+      const mockSchema = class TestSchema {};
+      const mockFileLoader = jest.fn();
+      (fileLoader as jest.Mock).mockReturnValue(mockFileLoader);
+      (TypedConfigModule.forRoot as jest.Mock).mockReturnValue({});
+
+      ConfigModule.forRoot({
+        schema: mockSchema,
+        ignoreEnvironmentVariableSubstitution: true,
+      });
+
+      expect(fileLoader).toHaveBeenCalledWith({
+        searchFrom: expect.any(String),
+        ignoreEnvironmentVariableSubstitution: true,
+      });
+    });
+
+    it('should include TypedConfigModule in imports', () => {
+      const mockSchema = class TestSchema {};
+      const mockFileLoader = jest.fn();
+      (fileLoader as jest.Mock).mockReturnValue(mockFileLoader);
+      const mockTypedConfigModule = {};
+      (TypedConfigModule.forRoot as jest.Mock).mockReturnValue(mockTypedConfigModule);
+
+      const result = ConfigModule.forRoot({
+        schema: mockSchema,
+      });
+
+      expect(result.imports).toContain(mockTypedConfigModule);
+    });
+  });
+});

package/src/config/config.module.ts

@@ -0,0 +1,50 @@
+import { DynamicModule, Global, Module } from '@nestjs/common';
+import { fileLoader, TypedConfigModule } from 'nest-typed-config';
+import { join } from 'path';
+
+export interface IConfigModuleOptions<T> {
+  /**
+   * The configuration schema class to validate against
+   */
+  schema: new () => T;
+  /**
+   * The path to search for configuration files
+   * Defaults to a 'config' directory two levels up from the current file
+   */
+  path?: string;
+  /**
+   * Whether to ignore environment variable substitution in config files
+   * Defaults to false (environment variables will be substituted)
+   */
+  ignoreEnvironmentVariableSubstitution?: boolean;
+}
+
+@Global()
+@Module({})
+export class ConfigModule {
+  /**
+   * Register the ConfigModule with a configuration schema
+   * @param options Configuration options including the schema class
+   * @returns A dynamic module configured with TypedConfigModule
+   */
+  static forRoot<T extends object>(options: IConfigModuleOptions<T>): DynamicModule {
+    const configPath = options.path ?? join(__dirname, '../../config');
+    const ignoreEnvSubstitution = options.ignoreEnvironmentVariableSubstitution ?? false;
+
+    return {
+      module: ConfigModule,
+      imports: [
+        TypedConfigModule.forRoot({
+          schema: options.schema,
+          load: [
+            fileLoader({
+              searchFrom: configPath,
+              ignoreEnvironmentVariableSubstitution: ignoreEnvSubstitution,
+            }),
+          ],
+        }),
+      ],
+      exports: [TypedConfigModule],
+    };
+  }
+}

package/src/config/default-app.config.ts

@@ -0,0 +1,9 @@
+import { ValidateNested } from 'class-validator';
+import { Type } from 'class-transformer';
+import { ServerConfig } from '../server/server.config';
+
+export class DefaultAppConfig {
+  @ValidateNested()
+  @Type(() => ServerConfig)
+  public readonly server!: ServerConfig;
+}

package/src/config/index.ts

@@ -0,0 +1,2 @@
+export * from './app.config';
+export * from './config.module';

package/src/health/health.controller.spec.ts

@@ -0,0 +1,48 @@
+import { mock, Mock } from 'ts-jest-mocker';
+import { HealthController } from './health.controller';
+import { HealthService } from './health.service';
+
+describe('HealthController', () => {
+  let controller: HealthController;
+  let healthService: Mock<HealthService>;
+
+  beforeEach(() => {
+    healthService = mock<HealthService>({
+      failIfMockNotProvided: false,
+    });
+    controller = new HealthController(healthService);
+  });
+
+  describe('getHealth', () => {
+    it('should return health status from service', () => {
+      const mockHealth = {
+        status: 'ok',
+        timestamp: '2024-01-15T10:00:00.000Z',
+        uptime: 123.45,
+      };
+
+      healthService.getHealth.mockReturnValue(mockHealth);
+
+      const result = controller.getHealth();
+
+      expect(result).toEqual(mockHealth);
+      expect(healthService.getHealth).toHaveBeenCalledTimes(1);
+    });
+
+    it('should return the exact response from service', () => {
+      const mockHealth = {
+        status: 'ok',
+        timestamp: '2024-01-20T15:30:00.000Z',
+        uptime: 999.99,
+      };
+
+      healthService.getHealth.mockReturnValue(mockHealth);
+
+      const result = controller.getHealth();
+
+      expect(result.status).toBe('ok');
+      expect(result.timestamp).toBe('2024-01-20T15:30:00.000Z');
+      expect(result.uptime).toBe(999.99);
+    });
+  });
+});

package/src/health/health.controller.ts

@@ -0,0 +1,17 @@
+import { Controller, Get, HttpCode, HttpStatus } from '@nestjs/common';
+import { HealthService } from './health.service';
+
+@Controller('health')
+export class HealthController {
+  constructor(private readonly healthService: HealthService) {}
+
+  @Get()
+  @HttpCode(HttpStatus.OK)
+  getHealth(): {
+    status: string;
+    timestamp: string;
+    uptime: number;
+  } {
+    return this.healthService.getHealth();
+  }
+}

package/src/health/health.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { HealthController } from './health.controller';
+import { HealthService } from './health.service';
+
+@Module({
+  controllers: [HealthController],
+  providers: [HealthService],
+  exports: [HealthService],
+})
+export class HealthModule {}

package/src/health/health.service.spec.ts

@@ -0,0 +1,46 @@
+import { HealthService } from './health.service';
+
+describe('HealthService', () => {
+  let service: HealthService;
+
+  beforeEach(() => {
+    service = new HealthService();
+  });
+
+  describe('getHealth', () => {
+    it('should return health status with ok status', () => {
+      const result = service.getHealth();
+
+      expect(result.status).toBe('ok');
+      expect(result).toHaveProperty('timestamp');
+      expect(result).toHaveProperty('uptime');
+    });
+
+    it('should return a valid ISO timestamp', () => {
+      const result = service.getHealth();
+      const timestamp = new Date(result.timestamp);
+
+      expect(timestamp.toISOString()).toBe(result.timestamp);
+      expect(timestamp.getTime()).toBeGreaterThan(0);
+    });
+
+    it('should return process uptime', () => {
+      const result = service.getHealth();
+
+      expect(typeof result.uptime).toBe('number');
+      expect(result.uptime).toBeGreaterThanOrEqual(0);
+      // Uptime should be approximately equal to process.uptime() (within 0.1 seconds)
+      expect(Math.abs(result.uptime - process.uptime())).toBeLessThan(0.1);
+    });
+
+    it('should return current timestamp', () => {
+      const before = new Date();
+      const result = service.getHealth();
+      const after = new Date();
+      const timestamp = new Date(result.timestamp);
+
+      expect(timestamp.getTime()).toBeGreaterThanOrEqual(before.getTime());
+      expect(timestamp.getTime()).toBeLessThanOrEqual(after.getTime());
+    });
+  });
+});

package/src/health/health.service.ts

@@ -0,0 +1,16 @@
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class HealthService {
+  getHealth(): {
+    status: string;
+    timestamp: string;
+    uptime: number;
+  } {
+    return {
+      status: 'ok',
+      timestamp: new Date().toISOString(),
+      uptime: process.uptime(),
+    };
+  }
+}

package/src/health/index.ts

@@ -0,0 +1,3 @@
+export * from './health.module';
+export * from './health.controller';
+export * from './health.service';

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './config';
+export * from './server';
+export * from './bootstrap';
+export * from './app.module';
+export * from './app.setup';

package/src/main.ts

@@ -0,0 +1,3 @@
+import { bootstrap } from './bootstrap';
+
+bootstrap();

package/src/server/index.ts

@@ -0,0 +1 @@
+export * from './server.config';

package/src/server/server.config.ts

@@ -0,0 +1,8 @@
+import { IsNumber } from 'class-validator';
+import { Type } from 'class-transformer';
+
+export class ServerConfig {
+  @IsNumber()
+  @Type(() => Number)
+  public readonly port!: number;
+}

package/src/swagger/index.ts

@@ -0,0 +1,2 @@
+export * from './swagger.factory';
+export * from './swagger.config';

package/src/swagger/swagger.config.ts

@@ -0,0 +1,20 @@
+import { IsBoolean, IsOptional, IsString } from 'class-validator';
+import { Transform } from 'class-transformer';
+
+export class SwaggerConfig {
+  @IsBoolean()
+  @Transform(({ value }) => {
+    if (typeof value === 'boolean') {
+      return value;
+    }
+    if (typeof value === 'string') {
+      return value.toLowerCase() === 'true';
+    }
+    return value;
+  })
+  public readonly enabled!: boolean;
+
+  @IsString()
+  @IsOptional()
+  public readonly path?: string;
+}

package/src/swagger/swagger.factory.ts

@@ -0,0 +1,25 @@
+import { INestApplication } from '@nestjs/common';
+import { DocumentBuilder, SwaggerDocumentOptions, SwaggerModule } from '@nestjs/swagger';
+import { SwaggerConfig } from './swagger.config';
+
+const swaggerDocumentOptions: SwaggerDocumentOptions = {
+  // operation names like createUser instead of UserController_createUser
+  operationIdFactory: (_controllerKey: string, methodKey: string) => methodKey,
+};
+
+export function configureAppWithSwagger(app: INestApplication, swaggerConfig: SwaggerConfig) {
+  if (swaggerConfig.enabled) {
+    const { path = 'docs' } = swaggerConfig;
+
+    const config = new DocumentBuilder()
+      .setTitle('Dismissible')
+      .setDescription('An API to handle dismissible items for users')
+      .setVersion('1.0')
+      .build();
+
+    const documentFactory = () => SwaggerModule.createDocument(app, config, swaggerDocumentOptions);
+    SwaggerModule.setup(path, app, documentFactory, {
+      useGlobalPrefix: true,
+    });
+  }
+}

package/tsconfig.app.json

@@ -0,0 +1,13 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../dist/out-tsc",
+    "module": "commonjs",
+    "types": ["node"],
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "target": "ES2021"
+  },
+  "exclude": ["node_modules", "**/*.spec.ts", "**/*.test.ts", "**/*.e2e-spec.ts"],
+  "include": ["src/**/*.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../tsconfig.base.json",
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.app.json"
+    }
+  ],
+  "compilerOptions": {
+    "esModuleInterop": true
+  }
+}