Even more

Co-authored-by: Patrik Oldsberg <poldsberg@gmail.com>
Co-authored-by: blam <ben@blam.sh>
Co-authored-by: Johan Haals <johan.haals@gmail.com>
Signed-off-by: Fredrik Adelöw <freben@gmail.com>

packages/backend-app-api/package.json

@@ -36,6 +36,8 @@
   "dependencies": {
     "@backstage/backend-plugin-api": "^0.0.0",
     "@backstage/backend-common": "^0.14.0",
+    "@backstage/backend-tasks": "^0.3.2",
+    "@backstage/plugin-permission-node": "^0.6.2",
     "winston": "^3.2.1"
   },
   "devDependencies": {

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

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2022 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 { CacheManager } from '@backstage/backend-common';
+import {
+  configServiceRef,
+  createServiceFactory,
+  cacheServiceRef,
+} from '@backstage/backend-plugin-api';
+
+// TODO: Work out some naming and implementation patterns for these
+export const cacheFactory = createServiceFactory({
+  service: cacheServiceRef,
+  deps: {
+    configFactory: configServiceRef,
+  },
+  factory: async ({ configFactory }) => {
+    const config = await configFactory('root');
+    const cacheManager = CacheManager.fromConfig(config);
+    return async (pluginId: string) => {
+      return cacheManager.forPlugin(pluginId);
+    };
+  },
+});

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

@@ -22,16 +22,19 @@ import {
 } from '@backstage/backend-plugin-api';
 import { loggerToWinstonLogger } from './loggerService';
 
-export const configService = createServiceFactory({
+export const configFactory = createServiceFactory({
   service: configServiceRef,
-  deps: { loggerFactory: loggerServiceRef },
+  deps: {
+    loggerFactory: loggerServiceRef,
+  },
   factory: async ({ loggerFactory }) => {
     const logger = await loggerFactory('root');
     const config = await loadBackendConfig({
       argv: process.argv,
       logger: loggerToWinstonLogger(logger),
     });
-
-    return async () => config;
+    return async () => {
+      return config;
+    };
   },
 });

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

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2022 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 { DatabaseManager } from '@backstage/backend-common';
+import {
+  configServiceRef,
+  createServiceFactory,
+  databaseServiceRef,
+} from '@backstage/backend-plugin-api';
+
+export const databaseFactory = createServiceFactory({
+  service: databaseServiceRef,
+  deps: {
+    configFactory: configServiceRef,
+  },
+  factory: async ({ configFactory }) => {
+    const config = await configFactory('root');
+    const databaseManager = DatabaseManager.fromConfig(config);
+    return async (pluginId: string) => {
+      return databaseManager.forPlugin(pluginId);
+    };
+  },
+});

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

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2022 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 { SingleHostDiscovery } from '@backstage/backend-common';
+import {
+  configServiceRef,
+  createServiceFactory,
+  discoveryServiceRef,
+} from '@backstage/backend-plugin-api';
+
+export const discoveryFactory = createServiceFactory({
+  service: discoveryServiceRef,
+  deps: {
+    configFactory: configServiceRef,
+  },
+  factory: async ({ configFactory }) => {
+    const config = await configFactory('root');
+    const discovery = SingleHostDiscovery.fromConfig(config);
+    return async () => {
+      return discovery;
+    };
+  },
+});

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

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2022 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 { cacheFactory } from './cacheService';
+import { configFactory } from './configService';
+import { databaseFactory } from './databaseService';
+import { discoveryFactory } from './discoveryService';
+import { loggerFactory } from './loggerService';
+import { permissionsFactory } from './permissionsService';
+import { schedulerFactory } from './schedulerService';
+import { tokenManagerFactory } from './tokenManagerService';
+import { urlReaderFactory } from './urlReaderService';
+
+export const defaultServiceFactories = [
+  cacheFactory,
+  configFactory,
+  databaseFactory,
+  discoveryFactory,
+  loggerFactory,
+  permissionsFactory,
+  schedulerFactory,
+  tokenManagerFactory,
+  urlReaderFactory,
+];

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

@@ -55,7 +55,6 @@ export const loggerFactory = createServiceFactory({
     const root = new BackstageLogger({
       winston: createRootLogger(),
     });
-
     return async (pluginId: string) => {
       return root.child({ pluginId });
     };

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

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2022 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 {
+  configServiceRef,
+  createServiceFactory,
+  discoveryServiceRef,
+  permissionsServiceRef,
+  tokenManagerServiceRef,
+} from '@backstage/backend-plugin-api';
+import { ServerPermissionClient } from '@backstage/plugin-permission-node';
+
+export const permissionsFactory = createServiceFactory({
+  service: permissionsServiceRef,
+  deps: {
+    configFactory: configServiceRef,
+    discoveryFactory: discoveryServiceRef,
+    tokenManagerFactory: tokenManagerServiceRef,
+  },
+  factory: async ({ configFactory, discoveryFactory, tokenManagerFactory }) => {
+    const config = await configFactory('root');
+    const discovery = await discoveryFactory('root');
+    const tokenManager = await tokenManagerFactory('root');
+    const permissions = ServerPermissionClient.fromConfig(config, {
+      discovery,
+      tokenManager,
+    });
+    return async (_pluginId: string) => {
+      return permissions;
+    };
+  },
+});

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

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2022 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 {
+  configServiceRef,
+  createServiceFactory,
+  schedulerServiceRef,
+} from '@backstage/backend-plugin-api';
+import { TaskScheduler } from '@backstage/backend-tasks';
+
+export const schedulerFactory = createServiceFactory({
+  service: schedulerServiceRef,
+  deps: {
+    configFactory: configServiceRef,
+  },
+  factory: async ({ configFactory }) => {
+    const config = await configFactory('root');
+    const taskScheduler = TaskScheduler.fromConfig(config);
+    return async (pluginId: string) => {
+      return taskScheduler.forPlugin(pluginId);
+    };
+  },
+});

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

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2022 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 {
+  configServiceRef,
+  loggerServiceRef,
+  createServiceFactory,
+  tokenManagerServiceRef,
+} from '@backstage/backend-plugin-api';
+import { ServerTokenManager } from '@backstage/backend-common';
+import { loggerToWinstonLogger } from './loggerService';
+
+export const tokenManagerFactory = createServiceFactory({
+  service: tokenManagerServiceRef,
+  deps: {
+    configFactory: configServiceRef,
+    loggerFactory: loggerServiceRef,
+  },
+  factory: async ({ configFactory, loggerFactory }) => {
+    const logger = await loggerFactory('root');
+    const config = await configFactory('root');
+    return async (_pluginId: string) => {
+      // doesn't the logger want to be inferred from the plugin tho here?
+      // maybe ... also why do we recreate it every time otherwise
+      // we should memoize on a per plugin right? so I think it's should be fine to re-use the plugin one
+      // we shouldn't recreate on a per plugin basis.
+      // hm - on the other hand, is this really ever called more than once?
+      // not this function right. should only be called when the plugin requests this serviceRef
+      // yeah so no need to worry about memo probably
+      // but we still want to scope the logger to the ServrTokenmanagfer>?
+      // mm sure maybe
+      // maybe in this case it doesn't provide so much value b
+      // oh hang on - isn't it up to THE MANAGER to make a child internally if it wants to do that
+      // so that it becomes a property intrinsic to that class, no matter how it's constructed
+      // or is that too much responsibility for it - making the constructor complex so to speak, making it harder to tweak that behavior
+      // this is not ultra efficient :)
+
+      // I think the naming here is wrong to be gonest
+      // this isn't like the cache manager or the database manager
+      // the manager name is confusuion i think
+      // aye perhaps
+      return ServerTokenManager.fromConfig(config, {
+        logger: loggerToWinstonLogger(logger),
+      });
+    };
+  },
+});

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

@@ -26,10 +26,10 @@ import { loggerToWinstonLogger } from './loggerService';
 export const urlReaderFactory = createServiceFactory({
   service: urlReaderServiceRef,
   deps: {
-    loggerFactory: loggerServiceRef,
     configFactory: configServiceRef,
+    loggerFactory: loggerServiceRef,
   },
-  factory: async ({ loggerFactory, configFactory }) => {
+  factory: async ({ configFactory, loggerFactory }) => {
     return async (pluginId: string) => {
       const logger = await loggerFactory(pluginId);
       return UrlReaders.default({

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

@@ -15,7 +15,7 @@
  */
 
 import { BackendRegistrable, ServiceRef } from '@backstage/backend-plugin-api';
-import { ApiHolder, BackendRegisterInit } from './types';
+import { BackendRegisterInit, ApiHolder } from './types';
 
 export class BackendInitializer {
   #started = false;
@@ -131,15 +131,20 @@ export class BackendInitializer {
       const toRemove = new Set<unknown>();
 
       for (const registerInit of registerInitsToOrder) {
-        const unInitializedDependents = Array.from(
-          registerInit.provides,
-        ).filter(r =>
-          registerInitsToOrder.some(
-            init => init !== registerInit && init.consumes.has(r),
-          ),
-        );
+        const unInitializedDependents = [];
+
+        for (const api of registerInit.provides) {
+          if (
+            registerInitsToOrder.some(
+              init => init !== registerInit && init.consumes.has(api),
+            )
+          ) {
+            unInitializedDependents.push(api);
+          }
+        }
 
         if (unInitializedDependents.length === 0) {
+          console.log(`DEBUG: pushed ${registerInit.id} to results`);
           orderedRegisterInits.push(registerInit);
           toRemove.add(registerInit);
         }

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

@@ -20,7 +20,7 @@ import {
   FactoryFunc,
   ServiceRef,
 } from '@backstage/backend-plugin-api';
-import { loggerFactory } from '../services/implementations/loggerService';
+import { defaultServiceFactories } from '../services/implementations';
 import { BackstageBackend } from './BackstageBackend';
 
 export interface Backend {
@@ -46,6 +46,8 @@ export type ApiHolder = {
 
 export function createBackend(options?: CreateBackendOptions): Backend {
   // TODO: merge with provided APIs
-  const defaultApis = [loggerFactory];
-  return new BackstageBackend([...defaultApis, ...(options?.apis ?? [])]);
+  return new BackstageBackend([
+    ...defaultServiceFactories,
+    ...(options?.apis ?? []),
+  ]);
 }

packages/backend-plugin-api/package.json

@@ -35,7 +35,9 @@
   },
   "dependencies": {
     "@backstage/config": "^1.0.1",
-    "@backstage/backend-common": "^0.14.0"
+    "@backstage/backend-common": "^0.14.0",
+    "@backstage/plugin-permission-common": "^0.6.2",
+    "@backstage/backend-tasks": "^0.3.2"
   },
   "devDependencies": {
     "@backstage/cli": "^0.17.2-next.0"

packages/backend-plugin-api/src/services/definitions/index.ts

@@ -36,3 +36,5 @@ export { cacheServiceRef } from './cacheServiceRef';
 export { databaseServiceRef } from './databaseServiceRef';
 export { discoveryServiceRef } from './discoveryServiceRef';
 export { tokenManagerServiceRef } from './tokenManagerServiceRef';
+export { permissionsServiceRef } from './permissionsServiceRef';
+export { schedulerServiceRef } from './schedulerServiceRef';

packages/backend-plugin-api/src/services/definitions/permissionsServiceRef.ts

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2022 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 { createServiceRef } from '../system/types';
+import {
+  PermissionAuthorizer,
+  PermissionEvaluator,
+} from '@backstage/plugin-permission-common';
+
+export const permissionsServiceRef = createServiceRef<
+  PermissionEvaluator | PermissionAuthorizer
+>({
+  id: 'core.permissions',
+});

packages/backend-plugin-api/src/services/definitions/schedulerServiceRef.ts

@@ -15,8 +15,8 @@
  */
 
 import { createServiceRef } from '../system/types';
-import { CacheManager } from '@backstage/backend-common';
+import { PluginTaskScheduler } from '@backstage/backend-tasks';
 
-export const cacheManagerServiceRef = createServiceRef<CacheManager>({
-  id: 'core.cacheManager',
+export const schedulerServiceRef = createServiceRef<PluginTaskScheduler>({
+  id: 'core.scheduler',
 });

packages/backend-plugin-api/src/services/definitions/scheldulerServiceRef.ts

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2022 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 { createServiceRef } from '../system/types';
+import {
+  PermissionAuthorizer,
+  PermissionEvaluator,
+} from '@backstage/plugin-permission-common';
+
+export const permissionsServiceRef = createServiceRef<
+  PermissionEvaluator | PermissionAuthorizer
+>({
+  id: 'core.permissions',
+});

packages/backend/src/next/index.ts

@@ -65,7 +65,7 @@ export const catalogPlugin = createBackendPlugin({
       },
       async init({ logger }) {
         //        const builder = await CatalogBuilder.create(env);
-        logger.log('boppp');
+        logger.info('boppp');
         console.log('I HAZ', processingExtensions.processors[0].process());
       },
     });