core-api: change ApiFactory.implements to .api

packages/app/src/apis.ts

@@ -40,7 +40,7 @@ import {
 export const apis = [
   // TODO(Rugvip): migrate to use /api
   createApiFactory({
-    implements: discoveryApiRef,
+    api: discoveryApiRef,
     deps: { configApi: configApiRef },
     factory: ({ configApi }) =>
       UrlPatternDiscovery.compile(
@@ -48,7 +48,7 @@ export const apis = [
       ),
   }),
   createApiFactory({
-    implements: graphQlBrowseApiRef,
+    api: graphQlBrowseApiRef,
     deps: { errorApi: errorApiRef, githubAuthApi: githubAuthApiRef },
     factory: ({ errorApi, githubAuthApi }) =>
       GraphQLEndpoints.from([

packages/core-api/src/apis/ApiFactoryRegistry.test.ts

@@ -18,12 +18,12 @@ import { ApiFactoryRegistry } from './ApiFactoryRegistry';
 import { createApiRef } from './ApiRef';
 
 const aRef = createApiRef<number>({ id: 'a', description: '' });
-const aFactory1 = { implements: aRef, deps: {}, factory: () => 1 };
-const aFactory2 = { implements: aRef, deps: {}, factory: () => 2 };
+const aFactory1 = { api: aRef, deps: {}, factory: () => 1 };
+const aFactory2 = { api: aRef, deps: {}, factory: () => 2 };
 const bRef = createApiRef<string>({ id: 'b', description: '' });
-const bFactory = { implements: bRef, deps: {}, factory: () => 'x' };
+const bFactory = { api: bRef, deps: {}, factory: () => 'x' };
 const cRef = createApiRef<string>({ id: 'c', description: '' });
-const cFactory = { implements: cRef, deps: {}, factory: () => 'y' };
+const cFactory = { api: cRef, deps: {}, factory: () => 'y' };
 
 describe('ApiFactoryRegistry', () => {
   it('should be empty when created', () => {
@@ -51,7 +51,7 @@ describe('ApiFactoryRegistry', () => {
     expect(registry.register('static', aFactory1)).toBe(true);
     expect(registry.get(aRef)).toBe(aFactory1);
     expect(registry.register('static', aFactory2)).toBe(false);
-    expect(registry.get(aRef)).toBe(aFactory2);
+    expect(registry.get(aRef)).toBe(aFactory1);
     expect(registry.register('app', aFactory2)).toBe(false);
     expect(registry.get(aRef)).toBe(aFactory1);
     expect(registry.getAllApis()).toEqual(new Set([aRef]));

packages/core-api/src/apis/ApiFactoryRegistry.ts

@@ -27,7 +27,7 @@ type ApiFactoryScope =
   | 'app' // Factories registered in the app, overriding default ones
   | 'static'; // APIs that can't be overridden, e.g. config
 
-enum ScopeLevels {
+enum ScopePriority {
   default = 10,
   app = 50,
   static = 100,
@@ -59,13 +59,13 @@ export class ApiFactoryRegistry implements ApiFactoryHolder {
     scope: ApiFactoryScope,
     factory: ApiFactory<Api, Deps>,
   ) {
-    const priority = ScopeLevels[scope];
-    const existing = this.factories.get(factory.implements);
-    if (existing && existing.priority > priority) {
+    const priority = ScopePriority[scope];
+    const existing = this.factories.get(factory.api);
+    if (existing && existing.priority >= priority) {
       return false;
     }
 
-    this.factories.set(factory.implements, { priority, factory });
+    this.factories.set(factory.api, { priority, factory });
     return true;
   }
 

packages/core-api/src/apis/ApiResolver.test.ts

@@ -25,17 +25,17 @@ const cRef = createApiRef<{ x: string }>({ id: 'c', description: '' });
 function createRegistry() {
   const registry = new ApiFactoryRegistry();
   registry.register('default', {
-    implements: aRef,
+    api: aRef,
     deps: {},
     factory: () => 1,
   });
   registry.register('default', {
-    implements: bRef,
+    api: bRef,
     deps: {},
     factory: () => 'b',
   });
   registry.register('default', {
-    implements: cRef,
+    api: cRef,
     deps: { b: bRef },
     factory: ({ b }) => ({ x: 'x', b }),
   });
@@ -45,17 +45,17 @@ function createRegistry() {
 function createLongCyclicRegistry() {
   const registry = new ApiFactoryRegistry();
   registry.register('default', {
-    implements: aRef,
+    api: aRef,
     deps: { b: bRef },
     factory: () => 1,
   });
   registry.register('default', {
-    implements: bRef,
+    api: bRef,
     deps: { c: cRef },
     factory: () => 'b',
   });
   registry.register('default', {
-    implements: cRef,
+    api: cRef,
     deps: { a: aRef },
     factory: () => ({ x: 'x' }),
   });
@@ -65,17 +65,17 @@ function createLongCyclicRegistry() {
 function createShortCyclicRegistry() {
   const registry = new ApiFactoryRegistry();
   registry.register('default', {
-    implements: aRef,
+    api: aRef,
     deps: { a: aRef },
     factory: () => 1,
   });
   registry.register('default', {
-    implements: bRef,
+    api: bRef,
     deps: { c: cRef },
     factory: () => 'b',
   });
   registry.register('default', {
-    implements: cRef,
+    api: cRef,
     deps: { b: bRef },
     factory: () => ({ x: 'x' }),
   });
@@ -162,7 +162,7 @@ describe('ApiResolver', () => {
     const registry = new ApiFactoryRegistry();
     const factory = jest.fn().mockReturnValue(2);
     registry.register('default', {
-      implements: aRef,
+      api: aRef,
       deps: {},
       factory,
     });

packages/core-api/src/apis/ApiResolver.ts

@@ -74,16 +74,11 @@ export class ApiResolver implements ApiHolder {
       return undefined;
     }
 
-    if (loading.includes(factory.implements)) {
-      throw new Error(
-        `Circular dependency of api factory for ${factory.implements}`,
-      );
+    if (loading.includes(factory.api)) {
+      throw new Error(`Circular dependency of api factory for ${factory.api}`);
     }
 
-    const deps = this.loadDeps(ref, factory.deps, [
-      ...loading,
-      factory.implements,
-    ]);
+    const deps = this.loadDeps(ref, factory.deps, [...loading, factory.api]);
     const api = factory.factory(deps);
     this.apis.set(ref, api);
     return api as T;

packages/core-api/src/apis/helpers.ts

@@ -40,7 +40,7 @@ export function createApiFactory<
 ): ApiFactory<Api, Deps> {
   if ('id' in factory) {
     return {
-      implements: factory,
+      api: factory,
       deps: {} as TypesToApiRefs<Deps>,
       factory: () => instance!,
     };

packages/core-api/src/apis/types.ts

@@ -31,7 +31,7 @@ export type ApiHolder = {
 };
 
 export type ApiFactory<Api, Deps extends { [name in string]: unknown }> = {
-  implements: ApiRef<Api>;
+  api: ApiRef<Api>;
   deps: TypesToApiRefs<Deps>;
   factory(deps: Deps): Api;
 };

packages/core-api/src/app/App.tsx

@@ -298,12 +298,12 @@ export class PrivateAppImpl implements BackstageApp {
     const registry = new ApiFactoryRegistry();
 
     registry.register('static', {
-      implements: appThemeApiRef,
+      api: appThemeApiRef,
       deps: {},
       factory: () => AppThemeSelector.createWithStorage(this.themes),
     });
     registry.register('static', {
-      implements: configApiRef,
+      api: configApiRef,
       deps: {},
       factory: () => {
         if (!this.configApi) {
@@ -315,7 +315,7 @@ export class PrivateAppImpl implements BackstageApp {
       },
     });
     registry.register('static', {
-      implements: identityApiRef,
+      api: identityApiRef,
       deps: {},
       factory: () => this.identityApi,
     });
@@ -329,7 +329,7 @@ export class PrivateAppImpl implements BackstageApp {
         if (!registry.register('default', factory)) {
           throw new Error(
             `Plugin ${plugin.getId()} tried to register duplicate or forbidden API factory for ${
-              factory.implements
+              factory.api
             }`,
           );
         }
@@ -339,7 +339,7 @@ export class PrivateAppImpl implements BackstageApp {
     for (const factory of this.apis) {
       if (!registry.register('app', factory)) {
         throw new Error(
-          `Duplicate or forbidden API factory for ${factory.implements} in app`,
+          `Duplicate or forbidden API factory for ${factory.api} in app`,
         );
       }
     }

packages/core/src/api-wrappers/defaultApis.ts

@@ -48,7 +48,7 @@ import {
 
 export const defaultApis = [
   createApiFactory({
-    implements: discoveryApiRef,
+    api: discoveryApiRef,
     deps: { configApi: configApiRef },
     factory: ({ configApi }) =>
       UrlPatternDiscovery.compile(
@@ -57,20 +57,20 @@ export const defaultApis = [
   }),
   createApiFactory(alertApiRef, new AlertApiForwarder()),
   createApiFactory({
-    implements: errorApiRef,
+    api: errorApiRef,
     deps: { alertApi: alertApiRef },
     factory: ({ alertApi }) =>
       new ErrorAlerter(alertApi, new ErrorApiForwarder()),
   }),
   createApiFactory({
-    implements: storageApiRef,
+    api: storageApiRef,
     deps: { errorApi: errorApiRef },
     factory: ({ errorApi }) => WebStorage.create({ errorApi }),
   }),
   createApiFactory(featureFlagsApiRef, new FeatureFlags()),
   createApiFactory(oauthRequestApiRef, new OAuthRequestManager()),
   createApiFactory({
-    implements: googleAuthApiRef,
+    api: googleAuthApiRef,
     deps: {
       discoveryApi: discoveryApiRef,
       oauthRequestApi: oauthRequestApiRef,
@@ -79,7 +79,7 @@ export const defaultApis = [
       GoogleAuth.create({ discoveryApi, oauthRequestApi }),
   }),
   createApiFactory({
-    implements: microsoftAuthApiRef,
+    api: microsoftAuthApiRef,
     deps: {
       discoveryApi: discoveryApiRef,
       oauthRequestApi: oauthRequestApiRef,
@@ -88,7 +88,7 @@ export const defaultApis = [
       MicrosoftAuth.create({ discoveryApi, oauthRequestApi }),
   }),
   createApiFactory({
-    implements: githubAuthApiRef,
+    api: githubAuthApiRef,
     deps: {
       discoveryApi: discoveryApiRef,
       oauthRequestApi: oauthRequestApiRef,
@@ -97,7 +97,7 @@ export const defaultApis = [
       GithubAuth.create({ discoveryApi, oauthRequestApi }),
   }),
   createApiFactory({
-    implements: oktaAuthApiRef,
+    api: oktaAuthApiRef,
     deps: {
       discoveryApi: discoveryApiRef,
       oauthRequestApi: oauthRequestApiRef,
@@ -106,7 +106,7 @@ export const defaultApis = [
       OktaAuth.create({ discoveryApi, oauthRequestApi }),
   }),
   createApiFactory({
-    implements: gitlabAuthApiRef,
+    api: gitlabAuthApiRef,
     deps: {
       discoveryApi: discoveryApiRef,
       oauthRequestApi: oauthRequestApiRef,
@@ -115,7 +115,7 @@ export const defaultApis = [
       GitlabAuth.create({ discoveryApi, oauthRequestApi }),
   }),
   createApiFactory({
-    implements: auth0AuthApiRef,
+    api: auth0AuthApiRef,
     deps: {
       discoveryApi: discoveryApiRef,
       oauthRequestApi: oauthRequestApiRef,
@@ -124,7 +124,7 @@ export const defaultApis = [
       Auth0Auth.create({ discoveryApi, oauthRequestApi }),
   }),
   createApiFactory({
-    implements: oauth2ApiRef,
+    api: oauth2ApiRef,
     deps: {
       discoveryApi: discoveryApiRef,
       oauthRequestApi: oauthRequestApiRef,

plugins/catalog/src/plugin.ts

@@ -26,7 +26,7 @@ export const plugin = createPlugin({
   id: 'catalog',
   apis: [
     createApiFactory({
-      implements: catalogApiRef,
+      api: catalogApiRef,
       deps: { discoveryApi: discoveryApiRef },
       factory: ({ discoveryApi }) => new CatalogClient({ discoveryApi }),
     }),

plugins/circleci/dev/index.tsx

@@ -20,9 +20,9 @@ import { circleCIApiRef, CircleCIApi } from '../src/api';
 
 createDevApp()
   .registerPlugin(plugin)
-  .registerApiFactory({
+  .registerApi({
+    api: circleCIApiRef,
     deps: {},
     factory: () => new CircleCIApi(),
-    implements: circleCIApiRef,
   })
   .render();

plugins/circleci/src/plugin.ts

@@ -23,7 +23,7 @@ export const plugin = createPlugin({
   id: 'circleci',
   apis: [
     createApiFactory({
-      implements: circleCIApiRef,
+      api: circleCIApiRef,
       deps: { configApi: configApiRef },
       factory: ({ configApi }) =>
         new CircleCIApi(

plugins/graphiql/dev/index.tsx

@@ -21,7 +21,7 @@ import { plugin, GraphQLEndpoints, graphQlBrowseApiRef } from '../src';
 createDevApp()
   .registerPlugin(plugin)
   .registerApi({
-    implements: graphQlBrowseApiRef,
+    api: graphQlBrowseApiRef,
     deps: {
       errorApi: errorApiRef,
       githubAuthApi: githubAuthApiRef,

plugins/jenkins/src/plugin.ts

@@ -32,7 +32,7 @@ export const plugin = createPlugin({
   id: 'jenkins',
   apis: [
     createApiFactory({
-      implements: jenkinsApiRef,
+      api: jenkinsApiRef,
       deps: { configApi: configApiRef },
       factory: ({ configApi }) =>
         new JenkinsApi(

plugins/lighthouse/dev/index.tsx

@@ -21,7 +21,7 @@ import { lighthouseApiRef, LighthouseRestApi } from '../src';
 createDevApp()
   .registerPlugin(plugin)
   .registerApi({
-    implements: lighthouseApiRef,
+    api: lighthouseApiRef,
     deps: {},
     factory: () => new LighthouseRestApi('http://localhost:3003'),
   })

plugins/lighthouse/src/plugin.ts

@@ -24,7 +24,7 @@ export const plugin = createPlugin({
   id: 'lighthouse',
   apis: [
     createApiFactory({
-      implements: lighthouseApiRef,
+      api: lighthouseApiRef,
       deps: { configApi: configApiRef },
       factory: ({ configApi }) => LighthouseRestApi.fromConfig(configApi),
     }),

plugins/rollbar/src/plugin.ts

@@ -29,7 +29,7 @@ export const plugin = createPlugin({
   id: 'rollbar',
   apis: [
     createApiFactory({
-      implements: rollbarApiRef,
+      api: rollbarApiRef,
       deps: { discoveryApi: discoveryApiRef },
       factory: ({ discoveryApi }) => new RollbarClient({ discoveryApi }),
     }),

plugins/scaffolder/src/plugin.ts

@@ -28,7 +28,7 @@ export const plugin = createPlugin({
   id: 'scaffolder',
   apis: [
     createApiFactory({
-      implements: scaffolderApiRef,
+      api: scaffolderApiRef,
       deps: { discoveryApi: discoveryApiRef },
       factory: ({ discoveryApi }) => new ScaffolderApi({ discoveryApi }),
     }),

plugins/techdocs/dev/index.tsx

@@ -21,12 +21,12 @@ import { techdocsStorageApiRef } from '../src';
 
 createDevApp()
   .registerApi({
+    api: techdocsStorageApiRef,
     deps: {},
     factory: () =>
       new TechDocsDevStorageApi({
         apiOrigin: 'http://localhost:3000/api',
       }),
-    implements: techdocsStorageApiRef,
   })
   .registerPlugin(plugin)
   .render();

plugins/techdocs/src/plugin.ts

@@ -56,7 +56,7 @@ export const plugin = createPlugin({
   id: 'techdocs',
   apis: [
     createApiFactory({
-      implements: techdocsStorageApiRef,
+      api: techdocsStorageApiRef,
       deps: { configApi: configApiRef },
       factory: ({ configApi }) =>
         new TechDocsStorageApi({