refactor all the things to use coreServices

Co-authored-by: Johan Haals <johan.haals@gmail.com>
Signed-off-by: Patrik Oldsberg <poldsberg@gmail.com>

packages/backend-app-api/src/services/implementations/cacheService.ts

@@ -16,18 +16,16 @@
 
 import { CacheManager } from '@backstage/backend-common';
 import {
-  configServiceRef,
+  coreServices,
   createServiceFactory,
-  pluginMetadataServiceRef,
-  cacheServiceRef,
 } from '@backstage/backend-plugin-api';
 
 /** @public */
 export const cacheFactory = createServiceFactory({
-  service: cacheServiceRef,
+  service: coreServices.cache,
   deps: {
-    config: configServiceRef,
-    plugin: pluginMetadataServiceRef,
+    config: coreServices.config,
+    plugin: coreServices.pluginMetadata,
   },
   async factory({ config }) {
     const cacheManager = CacheManager.fromConfig(config);

packages/backend-app-api/src/services/implementations/configService.ts

@@ -16,17 +16,16 @@
 
 import { loadBackendConfig } from '@backstage/backend-common';
 import {
-  configServiceRef,
+  coreServices,
   createServiceFactory,
   loggerToWinstonLogger,
-  rootLoggerServiceRef,
 } from '@backstage/backend-plugin-api';
 
 /** @public */
 export const configFactory = createServiceFactory({
-  service: configServiceRef,
+  service: coreServices.config,
   deps: {
-    logger: rootLoggerServiceRef,
+    logger: coreServices.rootLogger,
   },
   async factory({ logger }) {
     const config = await loadBackendConfig({

packages/backend-app-api/src/services/implementations/databaseService.ts

@@ -16,18 +16,16 @@
 
 import { DatabaseManager } from '@backstage/backend-common';
 import {
-  configServiceRef,
+  coreServices,
   createServiceFactory,
-  databaseServiceRef,
-  pluginMetadataServiceRef,
 } from '@backstage/backend-plugin-api';
 
 /** @public */
 export const databaseFactory = createServiceFactory({
-  service: databaseServiceRef,
+  service: coreServices.database,
   deps: {
-    config: configServiceRef,
-    plugin: pluginMetadataServiceRef,
+    config: coreServices.config,
+    plugin: coreServices.pluginMetadata,
   },
   async factory({ config }) {
     const databaseManager = DatabaseManager.fromConfig(config);

packages/backend-app-api/src/services/implementations/discoveryService.ts

@@ -16,16 +16,15 @@
 
 import { SingleHostDiscovery } from '@backstage/backend-common';
 import {
-  configServiceRef,
+  coreServices,
   createServiceFactory,
-  discoveryServiceRef,
 } from '@backstage/backend-plugin-api';
 
 /** @public */
 export const discoveryFactory = createServiceFactory({
-  service: discoveryServiceRef,
+  service: coreServices.discovery,
   deps: {
-    config: configServiceRef,
+    config: coreServices.config,
   },
   async factory({ config }) {
     const discovery = SingleHostDiscovery.fromConfig(config);

packages/backend-app-api/src/services/implementations/httpRouterService.ts

@@ -16,9 +16,7 @@
 
 import {
   createServiceFactory,
-  httpRouterServiceRef,
-  configServiceRef,
-  pluginMetadataServiceRef,
+  coreServices,
 } from '@backstage/backend-plugin-api';
 import Router from 'express-promise-router';
 import { Handler } from 'express';
@@ -36,10 +34,10 @@ export type HttpRouterFactoryOptions = {
 
 /** @public */
 export const httpRouterFactory = createServiceFactory({
-  service: httpRouterServiceRef,
+  service: coreServices.httpRouter,
   deps: {
-    config: configServiceRef,
-    plugin: pluginMetadataServiceRef,
+    config: coreServices.config,
+    plugin: coreServices.pluginMetadata,
   },
   async factory({ config }, options?: HttpRouterFactoryOptions) {
     const defaultPluginId = options?.indexPlugin ?? 'app';

packages/backend-app-api/src/services/implementations/lifecycleService.ts

@@ -16,10 +16,8 @@
 import {
   BackendLifecycle,
   createServiceFactory,
-  lifecycleServiceRef,
+  coreServices,
   loggerToWinstonLogger,
-  pluginMetadataServiceRef,
-  rootLoggerServiceRef,
   BackendLifecycleShutdownHook,
 } from '@backstage/backend-plugin-api';
 import { Logger } from 'winston';
@@ -80,10 +78,10 @@ class PluginScopedLifecycleImpl implements BackendLifecycle {
  * Allows plugins to register shutdown hooks that are run when the process is about to exit.
  * @public */
 export const lifecycleFactory = createServiceFactory({
-  service: lifecycleServiceRef,
+  service: coreServices.lifecycle,
   deps: {
-    logger: rootLoggerServiceRef,
-    plugin: pluginMetadataServiceRef,
+    logger: coreServices.rootLogger,
+    plugin: coreServices.pluginMetadata,
   },
   async factory({ logger }) {
     const rootLifecycle = new BackendLifecycleImpl(

packages/backend-app-api/src/services/implementations/loggerService.ts

@@ -16,17 +16,15 @@
 
 import {
   createServiceFactory,
-  loggerServiceRef,
-  pluginMetadataServiceRef,
-  rootLoggerServiceRef,
+  coreServices,
 } from '@backstage/backend-plugin-api';
 
 /** @public */
 export const loggerFactory = createServiceFactory({
-  service: loggerServiceRef,
+  service: coreServices.logger,
   deps: {
-    rootLogger: rootLoggerServiceRef,
-    plugin: pluginMetadataServiceRef,
+    rootLogger: coreServices.rootLogger,
+    plugin: coreServices.pluginMetadata,
   },
   async factory({ rootLogger }) {
     return async ({ plugin }) => {

packages/backend-app-api/src/services/implementations/permissionsService.ts

@@ -15,21 +15,18 @@
  */
 
 import {
-  configServiceRef,
+  coreServices,
   createServiceFactory,
-  discoveryServiceRef,
-  permissionsServiceRef,
-  tokenManagerServiceRef,
 } from '@backstage/backend-plugin-api';
 import { ServerPermissionClient } from '@backstage/plugin-permission-node';
 
 /** @public */
 export const permissionsFactory = createServiceFactory({
-  service: permissionsServiceRef,
+  service: coreServices.permissions,
   deps: {
-    config: configServiceRef,
-    discovery: discoveryServiceRef,
-    tokenManager: tokenManagerServiceRef,
+    config: coreServices.config,
+    discovery: coreServices.discovery,
+    tokenManager: coreServices.tokenManager,
   },
   async factory({ config }) {
     return async ({ discovery, tokenManager }) => {

packages/backend-app-api/src/services/implementations/rootLoggerService.ts

@@ -18,7 +18,7 @@ import { createRootLogger } from '@backstage/backend-common';
 import {
   createServiceFactory,
   Logger,
-  rootLoggerServiceRef,
+  coreServices,
 } from '@backstage/backend-plugin-api';
 import { Logger as WinstonLogger } from 'winston';
 
@@ -40,7 +40,7 @@ class BackstageLogger implements Logger {
 
 /** @public */
 export const rootLoggerFactory = createServiceFactory({
-  service: rootLoggerServiceRef,
+  service: coreServices.rootLogger,
   deps: {},
   async factory() {
     return BackstageLogger.fromWinston(createRootLogger());

packages/backend-app-api/src/services/implementations/schedulerService.ts

@@ -15,19 +15,17 @@
  */
 
 import {
-  configServiceRef,
+  coreServices,
   createServiceFactory,
-  pluginMetadataServiceRef,
-  schedulerServiceRef,
 } from '@backstage/backend-plugin-api';
 import { TaskScheduler } from '@backstage/backend-tasks';
 
 /** @public */
 export const schedulerFactory = createServiceFactory({
-  service: schedulerServiceRef,
+  service: coreServices.scheduler,
   deps: {
-    config: configServiceRef,
-    plugin: pluginMetadataServiceRef,
+    config: coreServices.config,
+    plugin: coreServices.pluginMetadata,
   },
   async factory({ config }) {
     const taskScheduler = TaskScheduler.fromConfig(config);

packages/backend-app-api/src/services/implementations/tokenManagerService.ts

@@ -15,20 +15,18 @@
  */
 
 import {
-  configServiceRef,
-  loggerServiceRef,
+  coreServices,
   createServiceFactory,
-  tokenManagerServiceRef,
   loggerToWinstonLogger,
 } from '@backstage/backend-plugin-api';
 import { ServerTokenManager } from '@backstage/backend-common';
 
 /** @public */
 export const tokenManagerFactory = createServiceFactory({
-  service: tokenManagerServiceRef,
+  service: coreServices.tokenManager,
   deps: {
-    config: configServiceRef,
-    logger: loggerServiceRef,
+    config: coreServices.config,
+    logger: coreServices.logger,
   },
   async factory() {
     return async ({ config, logger }) => {

packages/backend-app-api/src/services/implementations/urlReaderService.ts

@@ -16,19 +16,17 @@
 
 import { UrlReaders } from '@backstage/backend-common';
 import {
-  configServiceRef,
+  coreServices,
   createServiceFactory,
-  loggerServiceRef,
   loggerToWinstonLogger,
-  urlReaderServiceRef,
 } from '@backstage/backend-plugin-api';
 
 /** @public */
 export const urlReaderFactory = createServiceFactory({
-  service: urlReaderServiceRef,
+  service: coreServices.urlReader,
   deps: {
-    config: configServiceRef,
-    logger: loggerServiceRef,
+    config: coreServices.config,
+    logger: coreServices.logger,
   },
   async factory() {
     return async ({ config, logger }) => {

packages/backend-app-api/src/wiring/ServiceRegistry.test.ts

@@ -18,7 +18,7 @@ import {
   createServiceRef,
   createServiceFactory,
   ServiceRef,
-  pluginMetadataServiceRef,
+  coreServices,
 } from '@backstage/backend-plugin-api';
 import { ServiceRegistry } from './ServiceRegistry';
 
@@ -172,7 +172,7 @@ describe('ServiceRegistry', () => {
     const ref = createServiceRef<{ pluginId: string }>({ id: 'x' });
     const factory = createServiceFactory({
       service: ref,
-      deps: { meta: pluginMetadataServiceRef },
+      deps: { meta: coreServices.pluginMetadata },
       async factory() {
         return async ({ meta }) => ({ pluginId: meta.getId() });
       },

packages/backend-app-api/src/wiring/ServiceRegistry.ts

@@ -17,7 +17,7 @@
 import {
   ServiceFactory,
   ServiceRef,
-  pluginMetadataServiceRef,
+  coreServices,
 } from '@backstage/backend-plugin-api';
 import { stringifyError } from '@backstage/errors';
 
@@ -65,10 +65,10 @@ export class ServiceRegistry {
     pluginId: string,
   ): Promise<ServiceFactory> | undefined {
     // Special case handling of the plugin metadata service, generating a custom factory for it each time
-    if (ref.id === pluginMetadataServiceRef.id) {
+    if (ref.id === coreServices.pluginMetadata.id) {
       return Promise.resolve({
         scope: 'plugin',
-        service: pluginMetadataServiceRef,
+        service: coreServices.pluginMetadata,
         deps: {},
         factory: async () => async () => ({
           getId() {
@@ -114,7 +114,7 @@ export class ServiceRegistry {
 
   #checkForMissingDeps(factory: ServiceFactory, pluginId: string) {
     const missingDeps = Object.values(factory.deps).filter(ref => {
-      if (ref.id === pluginMetadataServiceRef.id) {
+      if (ref.id === coreServices.pluginMetadata.id) {
         return false;
       }
       if (this.#providedFactories.get(ref.id)) {