Skip to content

Open Source Wealth Management Software. Angular + NestJS + Prisma + Nx + TypeScript 🤍

5.2 KB
Raw Blame
import { ApiKeyService } from '@ghostfolio/api/services/api-key/api-key.service';
import { ApiModule } from '@ghostfolio/api/services/api/api.module';
import { AuthDeviceModule } from '@ghostfolio/api/services/auth-device/auth-device.module';
import { ConfigurationModule } from '@ghostfolio/api/services/configuration/configuration.module';
import { ConfigurationService } from '@ghostfolio/api/services/configuration/configuration.service';
import { FetchModule } from '@ghostfolio/api/services/fetch/fetch.module';
import { FetchService } from '@ghostfolio/api/services/fetch/fetch.service';
import { PrismaModule } from '@ghostfolio/api/services/prisma/prisma.module';
import { PropertyModule } from '@ghostfolio/api/services/property/property.module';
import { PortfolioSnapshotQueueModule } from '@ghostfolio/api/services/queues/portfolio-snapshot/portfolio-snapshot.module';
import { RedisCacheModule } from '@ghostfolio/api/services/redis-cache/redis-cache.module';
import { UserModule } from '@ghostfolio/api/services/user/user.module';

import { Logger, Module } from '@nestjs/common';
import { JwtModule } from '@nestjs/jwt';
import type { StrategyOptions } from 'passport-openidconnect';

import { ApiKeyStrategy } from './api-key.strategy';
import { AuthController } from './auth.controller';
import { AuthService } from './auth.service';
import { GoogleStrategy } from './google.strategy';
import { JwtStrategy } from './jwt.strategy';
import { getOidcDiscoveryUrl } from './oidc.helper';
import { OidcStrategy } from './oidc.strategy';
import { WebAuthService } from './web-auth.service';

@Module({
  controllers: [AuthController],
  imports: [
    ApiModule,
    AuthDeviceModule,
    ConfigurationModule,
    FetchModule,
    JwtModule.register({
      secret: process.env.JWT_SECRET_KEY,
      signOptions: { expiresIn: '180 days' }
    }),
    PortfolioSnapshotQueueModule,
    PrismaModule,
    PropertyModule,
    RedisCacheModule,
    UserModule
  ],
  providers: [
    ApiKeyService,
    ApiKeyStrategy,
    AuthService,
    GoogleStrategy,
    JwtStrategy,
    {
      inject: [AuthService, ConfigurationService, FetchService],
      provide: OidcStrategy,
      useFactory: async (
        authService: AuthService,
        configurationService: ConfigurationService,
        fetchService: FetchService
      ) => {
        const logger = new Logger('OidcStrategy');

        const isOidcEnabled = configurationService.get(
          'ENABLE_FEATURE_AUTH_OIDC'
        );

        if (!isOidcEnabled) {
          return null;
        }

        const issuer = configurationService.get('OIDC_ISSUER');
        const scope = configurationService.get('OIDC_SCOPE');

        const callbackURL =
          configurationService.get('OIDC_CALLBACK_URL') ||
          `${configurationService.get('ROOT_URL')}/api/auth/oidc/callback`;

        // Check for manual URL overrides
        const manualAuthorizationUrl = configurationService.get(
          'OIDC_AUTHORIZATION_URL'
        );
        const manualTokenUrl = configurationService.get('OIDC_TOKEN_URL');
        const manualUserInfoUrl =
          configurationService.get('OIDC_USER_INFO_URL');

        let authorizationURL: string;
        let tokenURL: string;
        let userInfoURL: string;

        if (manualAuthorizationUrl && manualTokenUrl && manualUserInfoUrl) {
          // Use manual URLs
          authorizationURL = manualAuthorizationUrl;
          tokenURL = manualTokenUrl;
          userInfoURL = manualUserInfoUrl;
        } else {
          // Fetch OIDC configuration from discovery endpoint
          try {
            const response = await fetchService.fetch(
              getOidcDiscoveryUrl(issuer)
            );

            if (!response.ok) {
              throw new Error(
                `OIDC discovery request failed with status ${response.status}`
              );
            }

            const config = (await response.json()) as {
              authorization_endpoint: string;
              token_endpoint: string;
              userinfo_endpoint: string;
            };

            // Manual URLs take priority over discovered ones
            authorizationURL =
              manualAuthorizationUrl || config.authorization_endpoint;
            tokenURL = manualTokenUrl || config.token_endpoint;
            userInfoURL = manualUserInfoUrl || config.userinfo_endpoint;
          } catch (error) {
            logger.error(error);
            throw new Error('Failed to fetch OIDC configuration from issuer');
          }
        }

        const clientID = configurationService.get('OIDC_CLIENT_ID');
        const clientSecret = configurationService.get('OIDC_CLIENT_SECRET');

        if (!clientID || !clientSecret || !issuer) {
          logger.error(
            'OIDC configuration incomplete: issuer, clientID, or clientSecret missing'
          );

          throw new Error('OIDC configuration incomplete');
        }

        const options: StrategyOptions = {
          authorizationURL,
          callbackURL,
          clientID,
          clientSecret,
          issuer,
          scope,
          tokenURL,
          userInfoURL
        };

        return new OidcStrategy(authService, options);
      }
    },
    WebAuthService
  ]
})
export class AuthModule {}