1src/domains/
2├── feature-flags/          # Existing admin module
3│   ├── feature-flags.controller.ts
4│   ├── feature-flags.service.ts
5│   └── feature-flags.module.ts
6└── sdk-runtime/            # New runtime module
7    ├── sdk-runtime.controller.ts
8    ├── sdk-runtime.service.ts
9    └── sdk-runtime.module.ts

1mkdir -p apps/sdk-service/src/domains/sdk-runtime

1# Development server should auto-reload
2# Test endpoints:
3curl http://localhost:6001/api/v1/flags?projectId=xxx&environment=development

1# Create module directory
2mkdir -p src/domains/module-name
3
4# Generate module with NestJS CLI (optional)
5nest generate module domains/module-name
6nest generate controller domains/module-name
7nest generate service domains/module-name
8
9# Test endpoints
10curl http://localhost:6001/your-route

1// sdk-runtime.service.ts
2import { Injectable } from '@nestjs/common';
3import { PrismaService } from '@/prisma/prisma.service';
4import type { FeatureFlag, Environment } from '@peek-a-boo/core';
5
6@Injectable()
7export class SdkRuntimeService {
8  constructor(private prismaService: PrismaService) {}
9
10  async getFlagsByEnvironment(
11    projectId: string,
12    environment: Environment,
13  ): Promise<FeatureFlag[]> {
14    return this.prismaService.featureFlag.findMany({
15      where: {
16        projectId,
17        environment,
18      },
19    });
20  }
21
22  async getFlagByKey(
23    projectId: string,
24    key: string,
25    environment: Environment,
26  ): Promise<FeatureFlag | null> {
27    return this.prismaService.featureFlag.findFirst({
28      where: {
29        projectId,
30        key,
31        environment,
32      },
33    });
34  }
35}

1// sdk-runtime.controller.ts
2import { Controller, Get, Query, Param, BadRequestException } from '@nestjs/common';
3import { SdkRuntimeService } from './sdk-runtime.service';
4import type { FeatureFlag, Environment } from '@peek-a-boo/core';
5
6@Controller('api/v1')
7export class SdkRuntimeController {
8  constructor(private readonly sdkRuntimeService: SdkRuntimeService) {}
9
10  @Get('flags')
11  async getFlags(
12    @Query('projectId') projectId: string,
13    @Query('environment') environment: string,
14  ): Promise<{ flags: FeatureFlag[]; environment: string }> {
15    // Validation
16    if (!projectId) {
17      throw new BadRequestException('projectId query parameter is required');
18    }
19
20    if (!environment) {
21      throw new BadRequestException('environment query parameter is required');
22    }
23
24    // Validate environment enum
25    const validEnvironments = ['DEVELOPMENT', 'STAGING', 'PRODUCTION'];
26    const env = environment.toUpperCase();
27    if (!validEnvironments.includes(env)) {
28      throw new BadRequestException(
29        `Invalid environment. Must be one of: ${validEnvironments.join(', ')}`,
30      );
31    }
32
33    const flags = await this.sdkRuntimeService.getFlagsByEnvironment(
34      projectId,
35      env as Environment,
36    );
37
38    return {
39      flags,
40      environment: env,
41    };
42  }
43
44  @Get('flags/:key')
45  async getFlag(
46    @Param('key') key: string,
47    @Query('projectId') projectId: string,
48    @Query('environment') environment: string,
49  ): Promise<FeatureFlag> {
50    if (!projectId) {
51      throw new BadRequestException('projectId query parameter is required');
52    }
53
54    if (!environment) {
55      throw new BadRequestException('environment query parameter is required');
56    }
57
58    const validEnvironments = ['DEVELOPMENT', 'STAGING', 'PRODUCTION'];
59    const env = environment.toUpperCase();
60    if (!validEnvironments.includes(env)) {
61      throw new BadRequestException(
62        `Invalid environment. Must be one of: ${validEnvironments.join(', ')}`,
63      );
64    }
65
66    const flag = await this.sdkRuntimeService.getFlagByKey(
67      projectId,
68      key,
69      env as Environment,
70    );
71
72    if (!flag) {
73      throw new BadRequestException(
74        `Flag with key "${key}" not found in ${env} environment`,
75      );
76    }
77
78    return flag;
79  }
80}

1// sdk-runtime.module.ts
2import { Module } from '@nestjs/common';
3import { SdkRuntimeController } from './sdk-runtime.controller';
4import { SdkRuntimeService } from './sdk-runtime.service';
5import { PrismaModule } from '@/prisma/prisma.module';
6
7@Module({
8  imports: [PrismaModule],      // Modules this module depends on
9  controllers: [SdkRuntimeController],  // HTTP controllers
10  providers: [SdkRuntimeService],       // Services/providers
11  exports: [SdkRuntimeService],         // What other modules can import
12})
13export class SdkRuntimeModule {}

1// app.module.ts
2import { Module } from '@nestjs/common';
3import { ConfigModule } from '@nestjs/config';
4import { PrismaModule } from './prisma/prisma.module';
5import { FeatureFlagsModule } from '@/domains/feature-flags/feature-flags.module';
6import { SdkRuntimeModule } from '@/domains/sdk-runtime/sdk-runtime.module';
7
8@Module({
9  imports: [
10    ConfigModule.forRoot({
11      isGlobal: true,
12    }),
13    PrismaModule,
14    FeatureFlagsModule,
15    SdkRuntimeModule,  // ← Register new module here
16  ],
17})
18export class AppModule {}

1// shared.module.ts
2@Module({
3  providers: [SharedService],
4  exports: [SharedService],  // Make available to importers
5})
6export class SharedModule {}
7
8// feature.module.ts
9@Module({
10  imports: [SharedModule],  // Import to use SharedService
11  providers: [FeatureService],
12})
13export class FeatureModule {}

1@Global()  // ← Makes module available everywhere
2@Module({
3  providers: [ConfigService],
4  exports: [ConfigService],
5})
6export class ConfigModule {}

1@Module({})
2export class DatabaseModule {
3  static forRoot(options: DatabaseOptions): DynamicModule {
4    return {
5      module: DatabaseModule,
6      providers: [
7        {
8          provide: 'DATABASE_OPTIONS',
9          useValue: options,
10        },
11        DatabaseService,
12      ],
13      exports: [DatabaseService],
14    };
15  }
16}
17
18// Usage
19@Module({
20  imports: [
21    DatabaseModule.forRoot({ host: 'localhost', port: 5432 })
22  ],
23})
24export class AppModule {}

1// 1. Service declares it's injectable
2@Injectable()
3export class MyService {
4  someMethod() { }
5}
6
7// 2. Module registers it as provider
8@Module({
9  providers: [MyService],
10})
11export class MyModule {}
12
13// 3. Other classes can inject it
14@Injectable()
15export class OtherService {
16  constructor(private myService: MyService) {}
17  // ↑ NestJS automatically provides instance
18}

1@Get()
2async getUsers() {
3  // Database queries in controller
4  return this.prismaService.user.findMany();
5}

1@Get()
2async getUsers() {
3  return this.userService.findAll();  // Delegate to service
4}

1// In service
2async getFlag(key: string) {
3  if (!key) throw new Error('Key required');  // HTTP concern in service
4}

1// In controller
2@Get(':key')
3async getFlag(@Param('key') key: string) {
4  if (!key) throw new BadRequestException('Key required');
5  return this.service.getFlag(key);
6}

1// Service method
2async getFlagsByEnvironment(
3  projectId: string,
4  environment: Environment,
5): Promise<FeatureFlag[]> {  // ← Typed return
6  // ...
7}

1@Module({
2  providers: [ServiceA, ServiceB],
3  exports: [ServiceA],  // Only ServiceA is public
4})

1import { Test, TestingModule } from '@nestjs/testing';
2import { SdkRuntimeService } from './sdk-runtime.service';
3import { PrismaService } from '@/prisma/prisma.service';
4
5describe('SdkRuntimeService', () => {
6  let service: SdkRuntimeService;
7  let prisma: PrismaService;
8
9  beforeEach(async () => {
10    const module: TestingModule = await Test.createTestingModule({
11      providers: [
12        SdkRuntimeService,
13        {
14          provide: PrismaService,
15          useValue: {
16            featureFlag: {
17              findMany: jest.fn(),
18              findFirst: jest.fn(),
19            },
20          },
21        },
22      ],
23    }).compile();
24
25    service = module.get<SdkRuntimeService>(SdkRuntimeService);
26    prisma = module.get<PrismaService>(PrismaService);
27  });
28
29  it('should fetch flags by environment', async () => {
30    const mockFlags = [{ key: 'test', enabled: true }];
31    jest.spyOn(prisma.featureFlag, 'findMany').mockResolvedValue(mockFlags);
32
33    const result = await service.getFlagsByEnvironment('project-1', 'DEVELOPMENT');
34    expect(result).toEqual(mockFlags);
35  });
36});

1import { Test, TestingModule } from '@nestjs/testing';
2import { SdkRuntimeController } from './sdk-runtime.controller';
3import { SdkRuntimeService } from './sdk-runtime.service';
4
5describe('SdkRuntimeController', () => {
6  let controller: SdkRuntimeController;
7  let service: SdkRuntimeService;
8
9  beforeEach(async () => {
10    const module: TestingModule = await Test.createTestingModule({
11      controllers: [SdkRuntimeController],
12      providers: [
13        {
14          provide: SdkRuntimeService,
15          useValue: {
16            getFlagsByEnvironment: jest.fn(),
17          },
18        },
19      ],
20    }).compile();
21
22    controller = module.get<SdkRuntimeController>(SdkRuntimeController);
23    service = module.get<SdkRuntimeService>(SdkRuntimeService);
24  });
25
26  it('should return flags', async () => {
27    const mockFlags = [{ key: 'test', enabled: true }];
28    jest.spyOn(service, 'getFlagsByEnvironment').mockResolvedValue(mockFlags);
29
30    const result = await controller.getFlags('project-1', 'development');
31    expect(result.flags).toEqual(mockFlags);
32    expect(result.environment).toBe('DEVELOPMENT');
33  });
34});

1@Module({
2  imports: [forwardRef(() => OtherModule)],
3})