Address review feedback

- Remove {@link} from @deprecated tag (freben feedback)
- Use Object.hasOwn instead of hasOwnProperty
- Use NotImplementedError instead of plain Error
- Add @backstage/errors dependency
- Add tests for withApis in core-compat-api

Signed-off-by: Patrik Oldsberg <poldsberg@gmail.com>
Made-with: Cursor

packages/core-compat-api/package.json

@@ -32,6 +32,7 @@
   },
   "dependencies": {
     "@backstage/core-plugin-api": "workspace:^",
+    "@backstage/errors": "workspace:^",
     "@backstage/frontend-plugin-api": "workspace:^",
     "@backstage/plugin-app-react": "workspace:^",
     "@backstage/plugin-catalog-react": "workspace:^",

packages/core-compat-api/src/withApis.test.tsx

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2026 The Backstage Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { createApiRef } from '@backstage/frontend-plugin-api';
+import {
+  TestApiProvider,
+  withLogCollector,
+} from '@backstage/frontend-test-utils';
+import { render, screen } from '@testing-library/react';
+import { withApis } from './withApis';
+
+describe('withApis', () => {
+  type MyApi = () => string;
+  const myApiRef = createApiRef<MyApi>({ id: 'my-api' });
+
+  const MyComponent = withApis({ getMessage: myApiRef })(({ getMessage }) => {
+    return <p>message: {getMessage()}</p>;
+  });
+
+  it('should inject APIs as props and set display name', () => {
+    render(
+      <TestApiProvider apis={[[myApiRef, () => 'hello']]}>
+        <MyComponent />
+      </TestApiProvider>,
+    );
+
+    expect(screen.getByText('message: hello')).toBeInTheDocument();
+    expect(MyComponent.displayName).toBe('withApis(Component)');
+  });
+
+  it('should ignore properties from the prototype', () => {
+    const otherRef = createApiRef<number>({ id: 'other' });
+    const proto = { other: otherRef };
+    const props = { getMessage: { enumerable: true, value: myApiRef } };
+    const obj = Object.create(proto, props) as {
+      getMessage: typeof myApiRef;
+      other: typeof otherRef;
+    };
+
+    const WeirdComponent = withApis(obj)(({ getMessage }) => {
+      return <p>message: {getMessage()}</p>;
+    });
+
+    render(
+      <TestApiProvider apis={[[myApiRef, () => 'hello']]}>
+        <WeirdComponent />
+      </TestApiProvider>,
+    );
+
+    expect(screen.getByText('message: hello')).toBeInTheDocument();
+  });
+
+  it('should throw NotImplementedError if the API is not available', () => {
+    expect(
+      withLogCollector(['error'], () => {
+        expect(() => {
+          render(
+            <TestApiProvider apis={[]}>
+              <MyComponent />
+            </TestApiProvider>,
+          );
+        }).toThrow('No implementation available for apiRef{my-api}');
+      }).error,
+    ).toEqual(
+      expect.arrayContaining([
+        expect.stringContaining(
+          'No implementation available for apiRef{my-api}',
+        ),
+      ]),
+    );
+  });
+});

packages/core-compat-api/src/withApis.tsx

@@ -15,11 +15,8 @@
  */
 
 import { ComponentType, PropsWithChildren } from 'react';
-import {
-  ApiRef,
-  TypesToApiRefs,
-  useApiHolder,
-} from '@backstage/frontend-plugin-api';
+import { TypesToApiRefs, useApiHolder } from '@backstage/frontend-plugin-api';
+import { NotImplementedError } from '@backstage/errors';
 
 /**
  * Wrapper for giving component an API context.
@@ -37,12 +34,14 @@ export function withApis<T extends {}>(apis: TypesToApiRefs<T>) {
       const impls = {} as T;
 
       for (const key in apis) {
-        if (apis.hasOwnProperty(key)) {
-          const ref: ApiRef<T[typeof key]> = apis[key];
+        if (Object.hasOwn(apis, key)) {
+          const ref = apis[key];
 
           const api = apiHolder.get(ref);
           if (!api) {
-            throw new Error(`No implementation available for ${ref}`);
+            throw new NotImplementedError(
+              `No implementation available for ${ref}`,
+            );
           }
           impls[key] = api;
         }

packages/frontend-plugin-api/src/apis/system/useApi.tsx

@@ -57,7 +57,7 @@ export function useApi<T>(apiRef: ApiRef<T>): T {
  * Wrapper for giving component an API context.
  *
  * @param apis - APIs for the context.
- * @deprecated Use {@link withApis} from `@backstage/core-compat-api` instead.
+ * @deprecated Use `withApis` from `@backstage/core-compat-api` instead.
  * @public
  */
 export function withApis<T extends {}>(apis: TypesToApiRefs<T>) {

yarn.lock

@@ -3580,6 +3580,7 @@ __metadata:
     "@backstage/cli": "workspace:^"
     "@backstage/core-app-api": "workspace:^"
     "@backstage/core-plugin-api": "workspace:^"
+    "@backstage/errors": "workspace:^"
     "@backstage/frontend-app-api": "workspace:^"
     "@backstage/frontend-plugin-api": "workspace:^"
     "@backstage/frontend-test-utils": "workspace:^"