chore: rename SignalService to SignalsService

Signed-off-by: Heikki Hellgren <heikki.hellgren@op.fi>

plugins/signals-node/README.md

@@ -6,28 +6,70 @@ Signals plugin allows backend plugins to publish messages to frontend plugins.
 
 ## Getting started
 
+### New backend system
+
+In `packages/backend/index.ts`, add the signals backend:
+
+```ts
+backend.add(import('@backstage/plugin-signals-backend'));
+```
+
+To use signals in your plugin, add it as a dependency to `my-plugin/plugin.ts`:
+
+```ts
+import {
+  coreServices,
+  createBackendPlugin,
+} from '@backstage/backend-plugin-api';
+import { signalsServiceRef } from '@backstage/plugin-signals-node';
+
+export const myPlugin = createBackendPlugin({
+  pluginId: 'my-plugin',
+  register(env) {
+    env.registerInit({
+      deps: {
+        httpRouter: coreServices.httpRouter,
+        signals: signalsServiceRef,
+      },
+      async init({ httpRouter, signals }) {
+        httpRouter.use(
+          await createRouter({
+            signals,
+          }),
+        );
+      },
+    });
+  },
+});
+```
+
+### Old backend system
+
 Add SignalService to your plugin environment in `packages/backend/src/types.ts`:
 
 ```ts
-import { SignalService } from '@backstage/plugin-signals-node';
+import { SignalsService } from '@backstage/plugin-signals-node';
 
 export type PluginEnvironment = {
   // ...
-  signalService: SignalService;
+  signals: SignalsService;
 };
 ```
 
 Add it also to your `makeCreateEnv` to allow access from the other plugins:
 
 ```ts
-import { SignalService } from '@backstage/plugin-signals-node';
+import {
+  SignalsService,
+  DefaultSignalsService,
+} from '@backstage/plugin-signals-node';
 import { DefaultEventBroker } from '@backstage/plugin-events-backend';
 
 function makeCreateEnv(config: Config) {
   // ...
 
   const eventBroker = new DefaultEventBroker(root.child({ type: 'plugin' }));
-  const signalService = DefaultSignalService.create({
+  const signalsService = DefaultSignalsService.create({
     eventBroker,
   });
 
@@ -36,7 +78,7 @@ function makeCreateEnv(config: Config) {
     return {
       logger,
       eventBroker,
-      signalService,
+      signals: signalsService,
       // ...
     };
   };
@@ -54,7 +96,7 @@ all subscribers, you can use `null` as `recipients` parameter.
 ```ts
 // Periodic sending example
 setInterval(async () => {
-  await signalService.publish({
+  await signals.publish({
     recipients: null,
     channel: 'my_plugin',
     message: {

plugins/signals-node/api-report.md

@@ -7,10 +7,13 @@ import { EventsService } from '@backstage/plugin-events-node';
 import { JsonObject } from '@backstage/types';
 import { ServiceRef } from '@backstage/backend-plugin-api';
 
+// @public @deprecated (undocumented)
+export const DefaultSignalService: typeof DefaultSignalsService;
+
 // @public (undocumented)
-export class DefaultSignalService implements SignalService {
+export class DefaultSignalsService implements SignalsService {
   // (undocumented)
-  static create(options: SignalServiceOptions): DefaultSignalService;
+  static create(options: SignalsServiceOptions): DefaultSignalsService;
   publish<TMessage extends JsonObject = JsonObject>(
     signal: SignalPayload<TMessage>,
   ): Promise<void>;
@@ -23,20 +26,26 @@ export type SignalPayload<TMessage extends JsonObject = JsonObject> = {
   message: TMessage;
 };
 
+// @public @deprecated (undocumented)
+export interface SignalService extends SignalsService {}
+
+// @public @deprecated (undocumented)
+export const signalService: ServiceRef<SignalsService, 'plugin'>;
+
 // @public (undocumented)
-export interface SignalService {
+export interface SignalsService {
   publish<TMessage extends JsonObject = JsonObject>(
     signal: SignalPayload<TMessage>,
   ): Promise<void>;
 }
 
 // @public (undocumented)
-export const signalService: ServiceRef<SignalService, 'plugin'>;
-
-// @public (undocumented)
-export type SignalServiceOptions = {
+export type SignalsServiceOptions = {
   events: EventsService;
 };
 
+// @public (undocumented)
+export const signalsServiceRef: ServiceRef<SignalsService, 'plugin'>;
+
 // (No @packageDocumentation comment for this package)
 ```

plugins/signals-node/src/DefaultSignalsService.test.ts

@@ -13,15 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { DefaultSignalService } from './DefaultSignalService';
+import { DefaultSignalsService } from './DefaultSignalsService';
 
-describe('DefaultSignalService', () => {
+describe('DefaultSignalsService', () => {
   const mockEvents = {
     publish: jest.fn(),
     subscribe: jest.fn(),
   };
 
-  const service = DefaultSignalService.create({ events: mockEvents });
+  const service = DefaultSignalsService.create({ events: mockEvents });
 
   it('should publish signal', () => {
     const signal = {

plugins/signals-node/src/DefaultSignalsService.ts

@@ -14,19 +14,19 @@
  * limitations under the License.
  */
 import { EventsService } from '@backstage/plugin-events-node';
-import { SignalPayload, SignalServiceOptions } from './types';
-import { SignalService } from './SignalService';
+import { SignalPayload, SignalsServiceOptions } from './types';
+import { SignalsService } from './SignalsService';
 import { JsonObject } from '@backstage/types';
 
 /** @public */
-export class DefaultSignalService implements SignalService {
+export class DefaultSignalsService implements SignalsService {
   private events: EventsService;
 
-  static create(options: SignalServiceOptions) {
-    return new DefaultSignalService(options);
+  static create(options: SignalsServiceOptions) {
+    return new DefaultSignalsService(options);
   }
 
-  private constructor(options: SignalServiceOptions) {
+  private constructor(options: SignalsServiceOptions) {
     ({ events: this.events } = options);
   }
 
@@ -43,3 +43,9 @@ export class DefaultSignalService implements SignalService {
     });
   }
 }
+
+/**
+ * @public
+ * @deprecated Use `DefaultSignalsService` instead
+ */
+export const DefaultSignalService = DefaultSignalsService;

plugins/signals-node/src/SignalsService.ts

@@ -17,7 +17,7 @@ import { SignalPayload } from './types';
 import { JsonObject } from '@backstage/types';
 
 /** @public */
-export interface SignalService {
+export interface SignalsService {
   /**
    * Publishes a signal to user refs to specific topic
    * @param signal - Signal to publish
@@ -26,3 +26,9 @@ export interface SignalService {
     signal: SignalPayload<TMessage>,
   ): Promise<void>;
 }
+
+/**
+ * @public
+ * @deprecated Use `SignalsService` instead
+ */
+export interface SignalService extends SignalsService {}

plugins/signals-node/src/index.ts

@@ -15,6 +15,6 @@
  */
 
 export * from './lib';
-export * from './DefaultSignalService';
-export * from './SignalService';
+export * from './DefaultSignalsService';
+export * from './SignalsService';
 export * from './types';

plugins/signals-node/src/lib.ts

@@ -17,12 +17,12 @@ import {
   createServiceFactory,
   createServiceRef,
 } from '@backstage/backend-plugin-api';
-import { DefaultSignalService } from './DefaultSignalService';
-import { SignalService } from './SignalService';
+import { DefaultSignalsService } from './DefaultSignalsService';
+import { SignalsService } from './SignalsService';
 import { eventsServiceRef } from '@backstage/plugin-events-node';
 
 /** @public */
-export const signalService = createServiceRef<SignalService>({
+export const signalsServiceRef = createServiceRef<SignalsService>({
   id: 'signals.service',
   scope: 'plugin',
   defaultFactory: async service =>
@@ -32,7 +32,13 @@ export const signalService = createServiceRef<SignalService>({
         events: eventsServiceRef,
       },
       factory({ events }) {
-        return DefaultSignalService.create({ events });
+        return DefaultSignalsService.create({ events });
       },
     }),
 });
+
+/**
+ * @public
+ * @deprecated Use `signalsServiceRef` instead
+ */
+export const signalService = signalsServiceRef;

plugins/signals-node/src/types.ts

@@ -19,7 +19,7 @@ import { JsonObject } from '@backstage/types';
 /**
  * @public
  */
-export type SignalServiceOptions = {
+export type SignalsServiceOptions = {
   events: EventsService;
 };