Address PR review comments

- Make ExtensionPointFactoryMiddleware an opaque type via new
  @internal/backend package using OpaqueType from @internal/opaque
- Use options object for createExtensionPointFactoryMiddleware
- Make middleware function async (returns Promise<T>)
- Remove extensionPointFactoryMiddleware from createBackend, keep only
  on createSpecializedBackend
- Export defaultServiceFactories from @backstage/backend-defaults

Signed-off-by: Jack Palmer <jackpalmer@spotify.com>

packages/backend-app-api/report.api.md

@@ -44,10 +44,10 @@ export interface BackendStartupResult {
 }
 
 // @public
-export function createExtensionPointFactoryMiddleware<T>(
-  extensionPoint: ExtensionPoint<T>,
-  middleware: (original: T) => T,
-): ExtensionPointFactoryMiddleware;
+export function createExtensionPointFactoryMiddleware<T>(options: {
+  extensionPoint: ExtensionPoint<T>;
+  middleware: (original: T) => Promise<T>;
+}): ExtensionPointFactoryMiddleware<T>;
 
 // @public (undocumented)
 export function createSpecializedBackend(
@@ -63,11 +63,9 @@ export interface CreateSpecializedBackendOptions {
 }
 
 // @public
-export interface ExtensionPointFactoryMiddleware<T = unknown> {
+export interface ExtensionPointFactoryMiddleware<_T = unknown> {
   // (undocumented)
-  extensionPoint: ExtensionPoint<T>;
-  // (undocumented)
-  middleware: (original: T) => T;
+  $$type: '@backstage/ExtensionPointFactoryMiddleware';
 }
 
 // @public

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

@@ -2122,10 +2122,13 @@ describe('BackendInitializer', () => {
       });
 
       const init = new BackendInitializer(baseFactories, [
-        createExtensionPointFactoryMiddleware(extensionPoint, original => ({
-          ...original,
-          values: [...original.values, 'from-middleware'],
-        })),
+        createExtensionPointFactoryMiddleware({
+          extensionPoint,
+          middleware: async original => ({
+            ...original,
+            values: [...original.values, 'from-middleware'],
+          }),
+        }),
       ]);
 
       init.add(testPlugin);
@@ -2170,10 +2173,13 @@ describe('BackendInitializer', () => {
       });
 
       const init = new BackendInitializer(baseFactories, [
-        createExtensionPointFactoryMiddleware(extensionPointA, original => ({
-          ...original,
-          values: [...original.values, 'wrapped'],
-        })),
+        createExtensionPointFactoryMiddleware({
+          extensionPoint: extensionPointA,
+          middleware: async original => ({
+            ...original,
+            values: [...original.values, 'wrapped'],
+          }),
+        }),
       ]);
 
       init.add(testPlugin);
@@ -2215,14 +2221,20 @@ describe('BackendInitializer', () => {
       });
 
       const init = new BackendInitializer(baseFactories, [
-        createExtensionPointFactoryMiddleware(extensionPoint, original => ({
-          ...original,
-          values: [...original.values, 'first'],
-        })),
-        createExtensionPointFactoryMiddleware(extensionPoint, original => ({
-          ...original,
-          values: [...original.values, 'second'],
-        })),
+        createExtensionPointFactoryMiddleware({
+          extensionPoint,
+          middleware: async original => ({
+            ...original,
+            values: [...original.values, 'first'],
+          }),
+        }),
+        createExtensionPointFactoryMiddleware({
+          extensionPoint,
+          middleware: async original => ({
+            ...original,
+            values: [...original.values, 'second'],
+          }),
+        }),
       ]);
 
       init.add(testPlugin);
@@ -2262,13 +2274,13 @@ describe('BackendInitializer', () => {
       });
 
       const init = new BackendInitializer(baseFactories, [
-        createExtensionPointFactoryMiddleware(
-          unregisteredExtensionPoint,
-          original => ({
+        createExtensionPointFactoryMiddleware({
+          extensionPoint: unregisteredExtensionPoint,
+          middleware: async original => ({
             ...original,
             values: [...original.values, 'never-applied'],
           }),
-        ),
+        }),
       ]);
 
       init.add(testPlugin);

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

@@ -29,6 +29,7 @@ import {
   ExtensionPointFactoryMiddleware,
   ServiceOrExtensionPoint,
 } from './types';
+import { OpaqueExtensionPointFactoryMiddleware } from '@internal/backend';
 // Direct internal import to avoid duplication
 // eslint-disable-next-line @backstage/no-relative-monorepo-imports
 import type {
@@ -210,8 +211,9 @@ export class BackendInitializer {
           },
         });
         for (const mw of this.#extensionPointFactoryMiddleware) {
-          if (mw.extensionPoint.id === ref.id) {
-            epImpl = (mw.middleware as (original: unknown) => unknown)(epImpl);
+          const internal = OpaqueExtensionPointFactoryMiddleware.toInternal(mw);
+          if (internal.extensionPointId === ref.id) {
+            epImpl = await internal.middleware(epImpl);
           }
         }
         result.set(name, epImpl);

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

@@ -20,6 +20,7 @@ import {
   ServiceRef,
   ServiceFactory,
 } from '@backstage/backend-plugin-api';
+import { OpaqueExtensionPointFactoryMiddleware } from '@internal/backend';
 
 /**
  * A middleware entry that reimplements a specific extension point's output.
@@ -28,9 +29,8 @@ import {
  *
  * @public
  */
-export interface ExtensionPointFactoryMiddleware<T = unknown> {
-  extensionPoint: ExtensionPoint<T>;
-  middleware: (original: T) => T;
+export interface ExtensionPointFactoryMiddleware<_T = unknown> {
+  $$type: '@backstage/ExtensionPointFactoryMiddleware';
 }
 
 /**
@@ -39,14 +39,14 @@ export interface ExtensionPointFactoryMiddleware<T = unknown> {
  *
  * @public
  */
-export function createExtensionPointFactoryMiddleware<T>(
-  extensionPoint: ExtensionPoint<T>,
-  middleware: (original: T) => T,
-): ExtensionPointFactoryMiddleware {
-  return {
-    extensionPoint: extensionPoint as ExtensionPoint<unknown>,
-    middleware: middleware as (original: unknown) => unknown,
-  };
+export function createExtensionPointFactoryMiddleware<T>(options: {
+  extensionPoint: ExtensionPoint<T>;
+  middleware: (original: T) => Promise<T>;
+}): ExtensionPointFactoryMiddleware<T> {
+  return OpaqueExtensionPointFactoryMiddleware.createInstance('v1', {
+    extensionPointId: options.extensionPoint.id,
+    middleware: options.middleware as (original: unknown) => Promise<unknown>,
+  });
 }
 
 /**