Service Factories

/**
 * Factory for creating authentication service instances
 * Provides token validation and credential management
 */
const authServiceFactory: ServiceFactory<AuthService>;

/**
 * Factory for creating HTTP authentication service instances
 * Handles HTTP request authentication and authorization
 */
const httpAuthServiceFactory: ServiceFactory<HttpAuthService>;

/**
 * Factory for creating permissions service instances
 * Manages authorization policies and permission checking
 */
const permissionsServiceFactory: ServiceFactory<PermissionsService>;

/**
 * Factory for creating permissions registry service instances
 * Registers and manages available permissions
 */
const permissionsRegistryServiceFactory: ServiceFactory<PermissionsRegistryService>;

/**
 * Factory for creating user info service instances
 * Provides user profile and metadata services
 */
const userInfoServiceFactory: ServiceFactory<UserInfoService>;

/**
 * Factory for creating database service instances
 * Provides database connections and query capabilities
 */
const databaseServiceFactory: ServiceFactory<DatabaseService>;

/**
 * Factory for creating logger service instances
 * Provides structured logging for plugins
 */
const loggerServiceFactory: ServiceFactory<LoggerService>;

/**
 * Factory for creating root logger service instances
 * Provides the main application logger
 */
const rootLoggerServiceFactory: ServiceFactory<RootLoggerService>;

/**
 * Factory for creating auditor service instances
 * Provides audit logging and event tracking
 */
const auditorServiceFactory: ServiceFactory<AuditorService>;

/**
 * Factory for creating HTTP router service instances
 * Provides Express.js routing for plugins
 */
const httpRouterServiceFactory: ServiceFactory<HttpRouterService>;

/**
 * Factory for creating root HTTP router service instances
 * Provides the main HTTP server and routing
 */
const rootHttpRouterServiceFactory: ServiceFactory<RootHttpRouterService>;

/**
 * Factory for creating root health service instances
 * Provides health check endpoints
 */
const rootHealthServiceFactory: ServiceFactory<RootHealthService>;

/**
 * Factory for creating cache service instances
 * Provides caching capabilities with multiple backends
 */
const cacheServiceFactory: ServiceFactory<CacheService>;

/**
 * Factory for creating discovery service instances
 * Enables service discovery and location
 */
const discoveryServiceFactory: ServiceFactory<DiscoveryService>;

/**
 * Factory for creating lifecycle service instances
 * Manages service startup and shutdown
 */
const lifecycleServiceFactory: ServiceFactory<LifecycleService>;

/**
 * Factory for creating root lifecycle service instances
 * Manages application lifecycle
 */
const rootLifecycleServiceFactory: ServiceFactory<RootLifecycleService>;

/**
 * Factory for creating scheduler service instances
 * Provides task scheduling capabilities
 */
const schedulerServiceFactory: ServiceFactory<SchedulerService>;

/**
 * Factory for creating URL reader service instances
 * Provides URL reading from various sources
 */
const urlReaderServiceFactory: ServiceFactory<UrlReaderService>;

/**
 * Factory for creating root configuration service instances
 * Provides application configuration management
 */
const rootConfigServiceFactory: ServiceFactory<RootConfigService>;

/**
 * Factory for creating actions registry service instances (Alpha)
 * Registers and manages scaffolder actions
 */
const actionsRegistryServiceFactory: ServiceFactory<ActionsRegistryService>;

/**
 * Factory for creating actions service instances (Alpha)
 * Provides scaffolder action execution
 */
const actionsServiceFactory: ServiceFactory<ActionsService>;

interface ServiceFactory<T = unknown> {
  service: ServiceRef<T>;
  deps: { [name in string]: ServiceRef<unknown> };
  factory(deps: { [name in string]: unknown }): T | Promise<T>;
}

interface ServiceRef<T = unknown> {
  id: string;
  scope?: 'root' | 'plugin';
}

// Core service interfaces
interface AuthService {
  authenticate(token: string): Promise<BackstageCredentials>;
}

interface HttpAuthService {
  credentials(req: Request): Promise<BackstageCredentials>;
}

interface DatabaseService {
  getClient(): Promise<Knex>;
}

interface LoggerService {
  info(message: string, meta?: LogMeta): void;
  warn(message: string, meta?: LogMeta): void;
  error(message: string, meta?: LogMeta): void;
  debug(message: string, meta?: LogMeta): void;
}

interface CacheService {
  get(key: string): Promise<JsonValue | undefined>;
  set(key: string, value: JsonValue, options?: CacheServiceSetOptions): Promise<void>;
  delete(key: string): Promise<void>;
}

import { createBackend } from "@backstage/backend-defaults";
import { loggerServiceFactory, databaseServiceFactory } from "@backstage/backend-defaults";

// Create backend and add specific service factories
const backend = createBackend();

// Service factories are already included in createBackend(),
// but can be customized if needed
backend.add(loggerServiceFactory);
backend.add(databaseServiceFactory);

import { createServiceFactory } from "@backstage/backend-plugin-api";
import { loggerServiceRef } from "@backstage/backend-plugin-api";

const customLoggerFactory = createServiceFactory({
  service: loggerServiceRef,
  deps: {},
  factory: async () => {
    // Custom logger implementation
    return new CustomLogger();
  },
});

backend.add(customLoggerFactory);