make the backend plugin ts files consistent

Signed-off-by: Fredrik Adelöw <freben@gmail.com>

.changeset/cuddly-bags-rescue.md

@@ -0,0 +1,22 @@
+---
+'@backstage/backend-test-utils': patch
+'@backstage/create-app': patch
+'@backstage/plugin-airbrake': patch
+'@backstage/plugin-app-backend': patch
+'@backstage/plugin-azure-devops-backend': patch
+'@backstage/plugin-badges-backend': patch
+'@backstage/plugin-bazaar-backend': patch
+'@backstage/plugin-catalog-backend': patch
+'@backstage/plugin-catalog-backend-module-msgraph': patch
+'@backstage/plugin-jenkins-backend': patch
+'@backstage/plugin-kafka': patch
+'@backstage/plugin-scaffolder-backend-module-cookiecutter': patch
+'@backstage/plugin-scaffolder-backend-module-rails': patch
+'@backstage/plugin-scaffolder-backend-module-yeoman': patch
+'@backstage/plugin-tech-insights-backend': patch
+'@backstage/plugin-tech-insights-backend-module-jsonfc': patch
+'@backstage/plugin-todo': patch
+'@backstage/plugin-todo-backend': patch
+---
+
+Minor README update

docs/auth/google/gcp-iap-auth.md

@@ -45,17 +45,14 @@ Add a `providerFactories` entry to the router in
 ```ts
 import { createGcpIapProvider } from '@backstage/plugin-auth-backend';
 
-export default async function createPlugin({
-  logger,
-  database,
-  config,
-  discovery,
-}: PluginEnvironment): Promise<Router> {
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
   return await createRouter({
-    logger,
-    config,
-    database,
-    discovery,
+    logger: env.logger,
+    config: env.config,
+    database: env.database,
+    discovery: env.discovery,
     providerFactories: {
       'gcp-iap': createGcpIapProvider({
         // Replace the auth handler if you want to customize the returned user

docs/auth/identity-resolver.md

@@ -29,9 +29,9 @@ sign-in resolvers and set them for any of the Authentication providers inside
 ```ts
 import { DEFAULT_NAMESPACE, stringifyEntityRef } from '@backstage/catalog-model';
 
-export default async function createPlugin({
-  ...
-}: PluginEnvironment): Promise<Router> {
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
   return await createRouter({
     ...
     providerFactories: {
@@ -105,13 +105,13 @@ matching `google.com/email` annotation.
 
 It can be enabled like this
 
-```tsx
+```ts
 // File: packages/backend/src/plugins/auth.ts
 import { googleEmailSignInResolver, createGoogleProvider } from '@backstage/plugin-auth-backend';
 
-export default async function createPlugin({
-  ...
-}: PluginEnvironment): Promise<Router> {
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
   return await createRouter({
     ...
     providerFactories: {
@@ -130,9 +130,9 @@ can do this using the `CatalogIdentityClient` provided as context to Sign-In
 resolvers:
 
 ```ts
-export default async function createPlugin({
-  ...
-}: PluginEnvironment): Promise<Router> {
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
   return await createRouter({
     ...
     providerFactories: {
@@ -174,11 +174,11 @@ display name and profile picture.
 This is also the place where you can do authorization and validation of the user
 and throw errors if the user should not be allowed access in Backstage.
 
-```tsx
+```ts
 // File: packages/backend/src/plugins/auth.ts
-export default async function createPlugin({
-  ...
-}: PluginEnvironment): Promise<Router> {
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
   return await createRouter({
     ...
     providerFactories: {

docs/features/kubernetes/installation.md

@@ -60,15 +60,15 @@ add the following:
 ```typescript
 // In packages/backend/src/plugins/kubernetes.ts
 import { KubernetesBuilder } from '@backstage/plugin-kubernetes-backend';
+import { Router } from 'express';
 import { PluginEnvironment } from '../types';
 
-export default async function createPlugin({
-  logger,
-  config,
-}: PluginEnvironment) {
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
   const { router } = await KubernetesBuilder.createBuilder({
-    logger,
-    config,
+    logger: env.logger,
+    config: env.config,
   }).build();
   return router;
 }

docs/features/search/getting-started.md

@@ -150,20 +150,24 @@ import {
 } from '@backstage/plugin-search-backend-node';
 import { PluginEnvironment } from '../types';
 import { DefaultCatalogCollator } from '@backstage/plugin-catalog-backend';
+import { Router } from 'express';
 
-export default async function createPlugin({
-  logger,
-  discovery,
-  tokenManager,
-}: PluginEnvironment) {
-  const searchEngine = new LunrSearchEngine({ logger });
-  const indexBuilder = new IndexBuilder({ logger, searchEngine });
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
+  const searchEngine = new LunrSearchEngine({
+    logger: env.logger,
+  });
+  const indexBuilder = new IndexBuilder({
+    logger: env.logger,
+    searchEngine,
+  });
 
   indexBuilder.addCollator({
     defaultRefreshIntervalSeconds: 600,
     collator: new DefaultCatalogCollator({
-      discovery,
-      tokenManager,
+      discovery: env.discovery,
+      tokenManager: env.tokenManager,
     }),
   });
 
@@ -174,7 +178,7 @@ export default async function createPlugin({
 
   return await createRouter({
     engine: indexBuilder.getSearchEngine(),
-    logger,
+    logger: env.logger,
   });
 }
 ```
@@ -285,13 +289,13 @@ which are responsible for providing documents
 number of collators with the `IndexBuilder` like this:
 
 ```typescript
-const indexBuilder = new IndexBuilder({ logger, searchEngine });
+const indexBuilder = new IndexBuilder({ logger: env.logger, searchEngine });
 
 indexBuilder.addCollator({
   defaultRefreshIntervalSeconds: 600,
   collator: new DefaultCatalogCollator({
-    discovery,
-    tokenManager,
+    discovery: env.discovery,
+    tokenManager: env.tokenManager,
   }),
 });
 
@@ -311,8 +315,8 @@ its `defaultRefreshIntervalSeconds` value, like this:
 indexBuilder.addCollator({
   defaultRefreshIntervalSeconds: 600,
   collator: new DefaultCatalogCollator({
-    discovery,
-    tokenManager,
+    discovery: env.discovery,
+    tokenManager: env.tokenManager,
   }),
 });
 ```

docs/features/search/how-to-guides.md

@@ -72,10 +72,10 @@ import { DefaultTechDocsCollatorFactory } from '@backstage/plugin-techdocs-backe
 ```typescript
 indexBuilder.addCollator({
   defaultRefreshIntervalSeconds: 600,
-  factory: DefaultTechDocsCollatorFactory.fromConfig(config, {
-    discovery,
-    logger,
-    tokenManager,
+  factory: DefaultTechDocsCollatorFactory.fromConfig(env.config, {
+    discovery: env.discovery,
+    logger: env.logger,
+    tokenManager: env.tokenManager,
   }),
 });
 ```
@@ -120,9 +120,9 @@ provided by `@backstage/plugin-catalog-backend` offers some configuration too!
 
 indexBuilder.addCollator({
   defaultRefreshIntervalSeconds: 600,
-  collator: DefaultCatalogCollator.fromConfig(config, {
-    discovery,
-    tokenManager,
+  collator: DefaultCatalogCollator.fromConfig(env.config, {
+    discovery: env.discovery,
+    tokenManager: env.tokenManager,
 +   filter: {
 +      kind: ['API', 'Component', 'Domain', 'Group', 'System', 'User'],
 +   },
@@ -167,18 +167,22 @@ provided by existing plugins, the migration process is fairly straightforward:
    +import { DefaultCatalogCollatorFactory } from '@backstage/plugin-catalog-backend';
    +import { DefaultTechDocsCollatorFactory } from '@backstage/plugin-techdocs-backend';
    // ...
-     const indexBuilder = new IndexBuilder({ logger, searchEngine });
+     const indexBuilder = new IndexBuilder({ logger: env.logger, searchEngine });
      indexBuilder.addCollator({
        defaultRefreshIntervalSeconds: 600,
-   -    collator: DefaultCatalogCollator.fromConfig(config, { discovery }),
-   +    factory: DefaultCatalogCollatorFactory.fromConfig(config, { discovery }),
+   -    collator: DefaultCatalogCollator.fromConfig(env.config, {
+          discovery: env.discovery,
+        }),
+   +    factory: DefaultCatalogCollatorFactory.fromConfig(env.config, {
+          discovery: env.discovery,
+        }),
      });
      indexBuilder.addCollator({
        defaultRefreshIntervalSeconds: 600,
-   -    collator: DefaultTechDocsCollator.fromConfig(config, {
-   +    factory: DefaultTechDocsCollatorFactory.fromConfig(config, {
-         discovery,
-         logger,
+   -     collator: DefaultTechDocsCollator.fromConfig(env.config, {
+   +     factory: DefaultTechDocsCollatorFactory.fromConfig(env.config, {
+           discovery: env.discovery,
+           logger: env.logger,
        }),
      });
    ```

docs/features/search/search-engines.md

@@ -17,7 +17,7 @@ provided search engines by using the exposed setter to set the modified query
 translator into the instance.
 
 ```typescript
-const searchEngine = new LunrSearchEngine({ logger });
+const searchEngine = new LunrSearchEngine({ logger: env.logger });
 searchEngine.setTranslator(new MyNewAndBetterQueryTranslator());
 ```
 
@@ -30,8 +30,8 @@ Lunr can be instantiated like this:
 
 ```typescript
 // app/backend/src/plugins/search.ts
-const searchEngine = new LunrSearchEngine({ logger });
-const indexBuilder = new IndexBuilder({ logger, searchEngine });
+const searchEngine = new LunrSearchEngine({ logger: env.logger });
+const indexBuilder = new IndexBuilder({ logger: env.logger, searchEngine });
 ```
 
 ## Postgres
@@ -58,9 +58,9 @@ configured and make the following changes to your backend:
 // In packages/backend/src/plugins/search.ts
 
 // Initialize a connection to a search engine.
-const searchEngine = (await PgSearchEngine.supported(database))
-  ? await PgSearchEngine.from({ database })
-  : new LunrSearchEngine({ logger });
+const searchEngine = (await PgSearchEngine.supported(env.database))
+  ? await PgSearchEngine.from({ database: env.database })
+  : new LunrSearchEngine({ logger: env.logger });
 ```
 
 ## ElasticSearch
@@ -74,10 +74,10 @@ Similarly to Lunr above, ElasticSearch can be set up like this:
 ```typescript
 // app/backend/src/plugins/search.ts
 const searchEngine = await ElasticSearchSearchEngine.initialize({
-  logger,
-  config,
+  logger: env.logger,
+  config: env.config,
 });
-const indexBuilder = new IndexBuilder({ logger, searchEngine });
+const indexBuilder = new IndexBuilder({ logger: env.logger, searchEngine });
 ```
 
 For the engine to be available, your backend package needs a dependency into

docs/features/software-catalog/descriptor-format.md

@@ -64,7 +64,7 @@ spec:
 
 This is the same entity as returned in JSON from the software catalog API:
 
-```js
+```json
 {
   "apiVersion": "backstage.io/v1alpha1",
   "kind": "Component",
@@ -79,11 +79,13 @@ This is the same entity as returned in JSON from the software catalog API:
     "labels": {
       "example.com/custom": "custom_label_value"
     },
-    "links": [{
-      "url": "https://admin.example-org.com",
-      "title": "Admin Dashboard",
-      "icon": "dashboard"
-    }],
+    "links": [
+      {
+        "url": "https://admin.example-org.com",
+        "title": "Admin Dashboard",
+        "icon": "dashboard"
+      }
+    ],
     "tags": ["java"],
     "name": "artist-web",
     "uid": "2152f463-549d-4d8d-a94d-ce2b7676c6e2"

docs/features/software-templates/writing-custom-actions.md

@@ -108,11 +108,11 @@ should have something similar to the below in
 ```ts
 return await createRouter({
   containerRunner,
-  logger,
-  config,
-  database,
   catalogClient,
-  reader,
+  logger: env.logger,
+  config: env.config,
+  database: env.database,
+  reader: env.reader,
 });
 ```
 
@@ -123,25 +123,25 @@ will set the available actions that the scaffolder has access to.
 import { createBuiltinActions } from '@backstage/plugin-scaffolder-backend';
 import { ScmIntegrations } from '@backstage/integration';
 
-const integrations = ScmIntegrations.fromConfig(config);
+const integrations = ScmIntegrations.fromConfig(env.config);
 
 const builtInActions = createBuiltinActions({
   containerRunner,
   integrations,
-  config,
   catalogClient,
-  reader,
+  config: env.config,
+  reader: env.reader,
 });
 
 const actions = [...builtInActions, createNewFileAction()];
 return await createRouter({
   containerRunner,
-  logger,
-  config,
-  database,
   catalogClient,
-  reader,
   actions,
+  logger: env.logger,
+  config: env.config,
+  database: env.database,
+  reader: env.reader,
 });
 ```
 

docs/features/techdocs/getting-started.md

@@ -81,18 +81,16 @@ import {
   Publisher,
 } from '@backstage/plugin-techdocs-backend';
 import Docker from 'dockerode';
+import { Router } from 'express';
 import { PluginEnvironment } from '../types';
 
-export default async function createPlugin({
-  logger,
-  config,
-  discovery,
-  reader,
-}: PluginEnvironment) {
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
   // Preparers are responsible for fetching source files for documentation.
-  const preparers = await Preparers.fromConfig(config, {
-    logger,
-    reader,
+  const preparers = await Preparers.fromConfig(env.config, {
+    logger: env.logger,
+    reader: env.reader,
   });
 
   // Docker client (conditionally) used by the generators, based on techdocs.generators config.
@@ -100,17 +98,17 @@ export default async function createPlugin({
   const containerRunner = new DockerContainerRunner({ dockerClient });
 
   // Generators are used for generating documentation sites.
-  const generators = await Generators.fromConfig(config, {
-    logger,
+  const generators = await Generators.fromConfig(env.config, {
+    logger: env.logger,
     containerRunner,
   });
 
   // Publisher is used for
   // 1. Publishing generated files to storage
   // 2. Fetching files from storage and passing them to TechDocs frontend.
-  const publisher = await Publisher.fromConfig(config, {
-    logger,
-    discovery,
+  const publisher = await Publisher.fromConfig(env.config, {
+    logger: env.logger,
+    discovery: env.discovery,
   });
 
   // checks if the publisher is working and logs the result
@@ -120,9 +118,9 @@ export default async function createPlugin({
     preparers,
     generators,
     publisher,
-    logger,
-    config,
-    discovery,
+    logger: env.logger,
+    config: env.config,
+    discovery: env.discovery,
   });
 }
 ```

docs/integrations/github/discovery.md

@@ -42,16 +42,16 @@ And then add the processors to your catalog builder:
    env: PluginEnvironment,
  ): Promise<Router> {
    const builder = await CatalogBuilder.create(env);
-+  const integrations = ScmIntegrations.fromConfig(config);
++  const integrations = ScmIntegrations.fromConfig(env.config);
 +  const githubCredentialsProvider =
 +    DefaultGithubCredentialsProvider.fromIntegrations(integrations);
 +  builder.addProcessor(
-+    GithubDiscoveryProcessor.fromConfig(config, {
-+      logger,
++    GithubDiscoveryProcessor.fromConfig(env.config, {
++      logger: env.logger,
 +      githubCredentialsProvider,
 +    }),
-+    GithubOrgReaderProcessor.fromConfig(config, {
-+      logger,
++    GithubOrgReaderProcessor.fromConfig(env.config, {
++      logger: env.logger,
 +      githubCredentialsProvider,
 +    }),
 +  );

docs/integrations/github/org.md

@@ -69,6 +69,6 @@ import { GithubOrgReaderProcessor } from '@backstage/plugin-catalog-backend';
 
 builder.replaceProcessors(
   // ... other processor replacements
-  GithubOrgReaderProcessor.fromConfig(config, { logger }),
+  GithubOrgReaderProcessor.fromConfig(env.config, { logger: env.logger }),
 );
 ```

docs/plugins/backend-plugin.md

@@ -76,9 +76,12 @@ following to it
 
 ```ts
 import { createRouter } from '@internal/plugin-carmen-backend';
+import { Router } from 'express';
 import { PluginEnvironment } from '../types';
 
-export default async function createPlugin(env: PluginEnvironment) {
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
   // Here is where you will add all of the required initialization code that
   // your backend plugin needs to be able to start!
 
@@ -124,7 +127,9 @@ function, there is a `database` field. You can use that to get a
 
 ```ts
 // in packages/backend/src/plugins/carmen.ts
-export default async function createPlugin(env: PluginEnvironment) {
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
   const db: Knex<any, unknown[]> = await env.database.getClient();
 
   // You will then pass this client into your actual plugin implementation

docs/plugins/testing.md

@@ -192,7 +192,7 @@ returns a result or displays an error or console message, like so:
 
 **`StringUtil ellipsis`**
 
-```js
+```ts
 export function ellipsis(text, maxLength, midCharIx = 0, ellipsis = '...') {
   // Do something blackbox. We should not care about the internals,
   // only inputs and outputs.
@@ -210,7 +210,7 @@ There are four things to test for in a utility function:
 
 > Handle Invalid Input (handle thrown errors):
 
-```js
+```ts
 it('Throws an error on improper arguments', () => {
   expect(() => {
     ellipsis();
@@ -220,7 +220,7 @@ it('Throws an error on improper arguments', () => {
 
 > Verify default input arguments:
 
-```js
+```ts
 it('Works with defaults', () => {
   expect(ellipsis('Hello world', 3)).toBe('Hel...');
   expect(ellipsis('', 3)).toBe('');
@@ -233,7 +233,7 @@ it('Works with defaults', () => {
 
 This is especially true for edge cases!
 
-```js
+```ts
 it('Works with midCharIx', () => {
   expect(ellipsis('Hello world', 3, 6)).toBe('...o w...');
   expect(ellipsis('', 3, 6)).toBe('');
@@ -265,7 +265,7 @@ For example:
 
 **`./MyApi.js`**
 
-```js
+```ts
 export {
   fetchSomethingFromServer: () => {
     // Live production call to a URI. Must be avoided during testing!
@@ -276,7 +276,7 @@ export {
 
 **`./__mocks__/MyApi.js`**
 
-```js
+```ts
 export {
   fetchSomethingFromServer: () => {
     // Simulate a production call, but avoid jest and just use a promise
@@ -287,7 +287,7 @@ export {
 
 **`./MyApi.test.js`**
 
-```js
+```ts
 /* eslint-disable import/first */
 
 jest.mock('./MyApi'); // Instruct Jest to swap all future imports of './MyApi.js' to './__mocks__/MyApi.js'

docs/plugins/url-reader.md

@@ -44,7 +44,7 @@ import { URLReaders } from '@backstage/backend-common';
 
 function makeCreateEnv(config: Config) {
   // ....
-  const reader = UrlReaders.default({ logger, config });
+  const reader = UrlReaders.default({ logger: root, config });
   //
 }
 ```

packages/backend/src/plugins/app.ts

@@ -18,15 +18,13 @@ import { createRouter } from '@backstage/plugin-app-backend';
 import { Router } from 'express';
 import { PluginEnvironment } from '../types';
 
-export default async function createPlugin({
-  logger,
-  config,
-  database,
-}: PluginEnvironment): Promise<Router> {
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
   return await createRouter({
-    logger,
-    config,
-    database,
+    logger: env.logger,
+    config: env.config,
+    database: env.database,
     appPackageName: 'example-app',
   });
 }

packages/backend/src/plugins/auth.ts

@@ -18,18 +18,14 @@ import { createRouter } from '@backstage/plugin-auth-backend';
 import { Router } from 'express';
 import { PluginEnvironment } from '../types';
 
-export default async function createPlugin({
-  logger,
-  database,
-  config,
-  discovery,
-  tokenManager,
-}: PluginEnvironment): Promise<Router> {
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
   return await createRouter({
-    logger,
-    config,
-    database,
-    discovery,
-    tokenManager,
+    logger: env.logger,
+    config: env.config,
+    database: env.database,
+    discovery: env.discovery,
+    tokenManager: env.tokenManager,
   });
 }

packages/backend/src/plugins/azure-devops.ts

@@ -18,9 +18,11 @@ import { createRouter } from '@backstage/plugin-azure-devops-backend';
 import { Router } from 'express';
 import type { PluginEnvironment } from '../types';
 
-export default function createPlugin({
-  logger,
-  config,
-}: PluginEnvironment): Promise<Router> {
-  return createRouter({ logger, config });
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
+  return createRouter({
+    logger: env.logger,
+    config: env.config,
+  });
 }

packages/backend/src/plugins/badges.ts

@@ -18,15 +18,15 @@ import {
   createRouter,
   createDefaultBadgeFactories,
 } from '@backstage/plugin-badges-backend';
+import { Router } from 'express';
 import { PluginEnvironment } from '../types';
 
-export default async function createPlugin({
-  config,
-  discovery,
-}: PluginEnvironment) {
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
   return await createRouter({
-    config,
-    discovery,
+    config: env.config,
+    discovery: env.discovery,
     badgeFactories: createDefaultBadgeFactories(),
   });
 }

packages/backend/src/plugins/codecoverage.ts

@@ -15,9 +15,12 @@
  */
 
 import { createRouter } from '@backstage/plugin-code-coverage-backend';
+import { Router } from 'express';
 import { PluginEnvironment } from '../types';
 
-export default async function createPlugin(env: PluginEnvironment) {
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
   return await createRouter({
     config: env.config,
     discovery: env.discovery,

packages/backend/src/plugins/graphql.ts

@@ -18,12 +18,11 @@ import { createRouter } from '@backstage/plugin-graphql-backend';
 import { Router } from 'express';
 import { PluginEnvironment } from '../types';
 
-export default async function createPlugin({
-  logger,
-  config,
-}: PluginEnvironment): Promise<Router> {
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
   return await createRouter({
-    logger,
-    config,
+    logger: env.logger,
+    config: env.config,
   });
 }

packages/backend/src/plugins/healthcheck.ts

@@ -18,8 +18,11 @@ import { createStatusCheckRouter } from '@backstage/backend-common';
 import { Router } from 'express';
 import { PluginEnvironment } from '../types';
 
-export default async function createRouter({
-  logger,
-}: PluginEnvironment): Promise<Router> {
-  return await createStatusCheckRouter({ logger, path: '/healthcheck' });
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
+  return await createStatusCheckRouter({
+    logger: env.logger,
+    path: '/healthcheck',
+  });
 }

packages/backend/src/plugins/jenkins.ts

@@ -22,18 +22,16 @@ import { Router } from 'express';
 import { PluginEnvironment } from '../types';
 import { CatalogClient } from '@backstage/catalog-client';
 
-export default async function createPlugin({
-  logger,
-  config,
-  discovery,
-}: PluginEnvironment): Promise<Router> {
-  const catalog = new CatalogClient({ discoveryApi: discovery });
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
+  const catalog = new CatalogClient({ discoveryApi: env.discovery });
 
   return await createRouter({
-    logger,
+    logger: env.logger,
     jenkinsInfoProvider: DefaultJenkinsInfoProvider.fromConfig({
       catalog,
-      config,
+      config: env.config,
     }),
   });
 }

packages/backend/src/plugins/kafka.ts

@@ -18,9 +18,11 @@ import { createRouter } from '@backstage/plugin-kafka-backend';
 import { Router } from 'express';
 import { PluginEnvironment } from '../types';
 
-export default async function createPlugin({
-  logger,
-  config,
-}: PluginEnvironment): Promise<Router> {
-  return await createRouter({ logger, config });
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
+  return await createRouter({
+    logger: env.logger,
+    config: env.config,
+  });
 }

packages/backend/src/plugins/kubernetes.ts

@@ -15,15 +15,15 @@
  */
 
 import { KubernetesBuilder } from '@backstage/plugin-kubernetes-backend';
+import { Router } from 'express';
 import { PluginEnvironment } from '../types';
 
-export default async function createPlugin({
-  logger,
-  config,
-}: PluginEnvironment) {
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
   const { router } = await KubernetesBuilder.createBuilder({
-    logger,
-    config,
+    logger: env.logger,
+    config: env.config,
   }).build();
   return router;
 }

packages/backend/src/plugins/permission.ts

@@ -35,15 +35,14 @@ class AllowAllPermissionPolicy implements PermissionPolicy {
 export default async function createPlugin(
   env: PluginEnvironment,
 ): Promise<Router> {
-  const { logger, discovery, config } = env;
   return await createRouter({
-    config,
-    logger,
-    discovery,
+    config: env.config,
+    logger: env.logger,
+    discovery: env.discovery,
     policy: new AllowAllPermissionPolicy(),
     identity: IdentityClient.create({
-      discovery,
-      issuer: await discovery.getExternalBaseUrl('auth'),
+      discovery: env.discovery,
+      issuer: await env.discovery.getExternalBaseUrl('auth'),
     }),
   });
 }

packages/backend/src/plugins/proxy.ts

@@ -18,10 +18,12 @@ import { createRouter } from '@backstage/plugin-proxy-backend';
 import { Router } from 'express';
 import { PluginEnvironment } from '../types';
 
-export default async function createPlugin({
-  logger,
-  config,
-  discovery,
-}: PluginEnvironment): Promise<Router> {
-  return await createRouter({ logger, config, discovery });
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
+  return await createRouter({
+    logger: env.logger,
+    config: env.config,
+    discovery: env.discovery,
+  });
 }

packages/backend/src/plugins/rollbar.ts

@@ -18,9 +18,11 @@ import { createRouter } from '@backstage/plugin-rollbar-backend';
 import { Router } from 'express';
 import type { PluginEnvironment } from '../types';
 
-export default async function createPlugin({
-  logger,
-  config,
-}: PluginEnvironment): Promise<Router> {
-  return await createRouter({ logger, config });
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
+  return await createRouter({
+    logger: env.logger,
+    config: env.config,
+  });
 }

packages/backend/src/plugins/scaffolder.ts

@@ -19,19 +19,18 @@ import { createRouter } from '@backstage/plugin-scaffolder-backend';
 import { Router } from 'express';
 import type { PluginEnvironment } from '../types';
 
-export default async function createPlugin({
-  logger,
-  config,
-  database,
-  reader,
-  discovery,
-}: PluginEnvironment): Promise<Router> {
-  const catalogClient = new CatalogClient({ discoveryApi: discovery });
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
+  const catalogClient = new CatalogClient({
+    discoveryApi: env.discovery,
+  });
+
   return await createRouter({
-    logger,
-    config,
-    database,
-    catalogClient,
-    reader,
+    logger: env.logger,
+    config: env.config,
+    database: env.database,
+    catalogClient: catalogClient,
+    reader: env.reader,
   });
 }

packages/backend/src/plugins/search.ts

@@ -13,11 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import {
-  PluginDatabaseManager,
-  useHotCleanup,
-} from '@backstage/backend-common';
-import { Config } from '@backstage/config';
+
+import { useHotCleanup } from '@backstage/backend-common';
 import { DefaultCatalogCollatorFactory } from '@backstage/plugin-catalog-backend';
 import { createRouter } from '@backstage/plugin-search-backend';
 import { ElasticSearchSearchEngine } from '@backstage/plugin-search-backend-module-elasticsearch';
@@ -28,60 +25,52 @@ import {
   SearchEngine,
 } from '@backstage/plugin-search-backend-node';
 import { DefaultTechDocsCollatorFactory } from '@backstage/plugin-techdocs-backend';
-import { Logger } from 'winston';
+import { Router } from 'express';
 import { PluginEnvironment } from '../types';
 
-async function createSearchEngine({
-  logger,
-  database,
-  config,
-}: {
-  logger: Logger;
-  database: PluginDatabaseManager;
-  config: Config;
-}): Promise<SearchEngine> {
-  if (config.has('search.elasticsearch')) {
+async function createSearchEngine(
+  env: PluginEnvironment,
+): Promise<SearchEngine> {
+  if (env.config.has('search.elasticsearch')) {
     return await ElasticSearchSearchEngine.fromConfig({
-      logger,
-      config,
+      logger: env.logger,
+      config: env.config,
     });
   }
 
-  if (await PgSearchEngine.supported(database)) {
-    return await PgSearchEngine.from({ database });
+  if (await PgSearchEngine.supported(env.database)) {
+    return await PgSearchEngine.from({ database: env.database });
   }
 
-  return new LunrSearchEngine({ logger });
+  return new LunrSearchEngine({ logger: env.logger });
 }
 
-export default async function createPlugin({
-  logger,
-  permissions,
-  discovery,
-  config,
-  database,
-  tokenManager,
-}: PluginEnvironment) {
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
   // Initialize a connection to a search engine.
-  const searchEngine = await createSearchEngine({ config, logger, database });
-  const indexBuilder = new IndexBuilder({ logger, searchEngine });
+  const searchEngine = await createSearchEngine(env);
+  const indexBuilder = new IndexBuilder({
+    logger: env.logger,
+    searchEngine,
+  });
 
   // Collators are responsible for gathering documents known to plugins. This
   // particular collator gathers entities from the software catalog.
   indexBuilder.addCollator({
     defaultRefreshIntervalSeconds: 600,
-    factory: DefaultCatalogCollatorFactory.fromConfig(config, {
-      discovery,
-      tokenManager,
+    factory: DefaultCatalogCollatorFactory.fromConfig(env.config, {
+      discovery: env.discovery,
+      tokenManager: env.tokenManager,
     }),
   });
 
   indexBuilder.addCollator({
     defaultRefreshIntervalSeconds: 600,
-    factory: DefaultTechDocsCollatorFactory.fromConfig(config, {
-      discovery,
-      logger,
-      tokenManager,
+    factory: DefaultTechDocsCollatorFactory.fromConfig(env.config, {
+      discovery: env.discovery,
+      logger: env.logger,
+      tokenManager: env.tokenManager,
     }),
   });
 
@@ -97,8 +86,8 @@ export default async function createPlugin({
   return await createRouter({
     engine: indexBuilder.getSearchEngine(),
     types: indexBuilder.getDocumentTypes(),
-    permissions,
-    config,
-    logger,
+    permissions: env.permissions,
+    config: env.config,
+    logger: env.logger,
   });
 }

packages/backend/src/plugins/techInsights.ts

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 import {
   createRouter,
   buildTechInsightsContext,
@@ -28,17 +29,14 @@ import {
   JSON_RULE_ENGINE_CHECK_TYPE,
 } from '@backstage/plugin-tech-insights-backend-module-jsonfc';
 
-export default async function createPlugin({
-  logger,
-  config,
-  discovery,
-  database,
-}: PluginEnvironment): Promise<Router> {
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
   const techInsightsContext = await buildTechInsightsContext({
-    logger,
-    config,
-    database,
-    discovery,
+    logger: env.logger,
+    config: env.config,
+    database: env.database,
+    discovery: env.discovery,
     factRetrievers: [
       createFactRetrieverRegistration({
         cadence: '1 1 1 * *', // Example cron, At 01:01 on day-of-month 1.
@@ -54,6 +52,7 @@ export default async function createPlugin({
       }),
     ],
     factCheckerFactory: new JsonRulesEngineFactCheckerFactory({
+      logger: env.logger,
       checks: [
         {
           id: 'simpleTestCheck',
@@ -93,13 +92,12 @@ export default async function createPlugin({
           },
         },
       ],
-      logger,
     }),
   });
 
   return await createRouter({
     ...techInsightsContext,
-    logger,
-    config,
+    logger: env.logger,
+    config: env.config,
   });
 }

packages/backend/src/plugins/techdocs.ts

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 import { DockerContainerRunner } from '@backstage/backend-common';
 import {
   createRouter,
@@ -24,17 +25,13 @@ import Docker from 'dockerode';
 import { Router } from 'express';
 import { PluginEnvironment } from '../types';
 
-export default async function createPlugin({
-  logger,
-  config,
-  discovery,
-  reader,
-  cache,
-}: PluginEnvironment): Promise<Router> {
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
   // Preparers are responsible for fetching source files for documentation.
-  const preparers = await Preparers.fromConfig(config, {
-    logger,
-    reader,
+  const preparers = await Preparers.fromConfig(env.config, {
+    logger: env.logger,
+    reader: env.reader,
   });
 
   // Docker client (conditionally) used by the generators, based on techdocs.generators config.
@@ -42,17 +39,17 @@ export default async function createPlugin({
   const containerRunner = new DockerContainerRunner({ dockerClient });
 
   // Generators are used for generating documentation sites.
-  const generators = await Generators.fromConfig(config, {
-    logger,
+  const generators = await Generators.fromConfig(env.config, {
+    logger: env.logger,
     containerRunner,
   });
 
   // Publisher is used for
   // 1. Publishing generated files to storage
   // 2. Fetching files from storage and passing them to TechDocs frontend.
-  const publisher = await Publisher.fromConfig(config, {
-    logger,
-    discovery,
+  const publisher = await Publisher.fromConfig(env.config, {
+    logger: env.logger,
+    discovery: env.discovery,
   });
 
   // checks if the publisher is working and logs the result
@@ -62,9 +59,9 @@ export default async function createPlugin({
     preparers,
     generators,
     publisher,
-    logger,
-    config,
-    discovery,
-    cache,
+    logger: env.logger,
+    config: env.config,
+    discovery: env.discovery,
+    cache: env.cache,
   });
 }

packages/backend/src/plugins/todo.ts

@@ -22,21 +22,24 @@ import {
 import { Router } from 'express';
 import { PluginEnvironment } from '../types';
 
-export default async function createPlugin({
-  logger,
-  reader,
-  config,
-  discovery,
-}: PluginEnvironment): Promise<Router> {
-  const todoReader = TodoScmReader.fromConfig(config, {
-    logger,
-    reader,
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
+  const todoReader = TodoScmReader.fromConfig(env.config, {
+    logger: env.logger,
+    reader: env.reader,
   });
-  const catalogClient = new CatalogClient({ discoveryApi: discovery });
+
+  const catalogClient = new CatalogClient({
+    discoveryApi: env.discovery,
+  });
+
   const todoService = new TodoReaderService({
     todoReader,
     catalogClient,
   });
 
-  return await createRouter({ todoService });
+  return await createRouter({
+    todoService,
+  });
 }

packages/create-app/templates/default-app/packages/backend/src/plugins/app.ts

@@ -2,15 +2,13 @@ import { createRouter } from '@backstage/plugin-app-backend';
 import { Router } from 'express';
 import { PluginEnvironment } from '../types';
 
-export default async function createPlugin({
-  logger,
-  config,
-  database,
-}: PluginEnvironment): Promise<Router> {
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
   return await createRouter({
-    logger,
-    config,
-    database,
+    logger: env.logger,
+    config: env.config,
+    database: env.database,
     appPackageName: 'app',
   });
 }

packages/create-app/templates/default-app/packages/backend/src/plugins/auth.ts

@@ -2,18 +2,14 @@ import { createRouter } from '@backstage/plugin-auth-backend';
 import { Router } from 'express';
 import { PluginEnvironment } from '../types';
 
-export default async function createPlugin({
-  logger,
-  database,
-  config,
-  discovery,
-  tokenManager,
-}: PluginEnvironment): Promise<Router> {
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
   return await createRouter({
-    logger,
-    config,
-    database,
-    discovery,
-    tokenManager,
+    logger: env.logger,
+    config: env.config,
+    database: env.database,
+    discovery: env.discovery,
+    tokenManager: env.tokenManager,
   });
 }

packages/create-app/templates/default-app/packages/backend/src/plugins/proxy.ts

@@ -2,10 +2,12 @@ import { createRouter } from '@backstage/plugin-proxy-backend';
 import { Router } from 'express';
 import { PluginEnvironment } from '../types';
 
-export default async function createPlugin({
-  logger,
-  config,
-  discovery,
-}: PluginEnvironment): Promise<Router> {
-  return await createRouter({ logger, config, discovery });
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
+  return await createRouter({
+    logger: env.logger,
+    config: env.config,
+    discovery: env.discovery,
+  });
 }

packages/create-app/templates/default-app/packages/backend/src/plugins/scaffolder.ts

@@ -3,19 +3,18 @@ import { createRouter } from '@backstage/plugin-scaffolder-backend';
 import { Router } from 'express';
 import type { PluginEnvironment } from '../types';
 
-export default async function createPlugin({
-  logger,
-  config,
-  database,
-  reader,
-  discovery,
-}: PluginEnvironment): Promise<Router> {
-  const catalogClient = new CatalogClient({ discoveryApi: discovery });
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
+  const catalogClient = new CatalogClient({
+    discoveryApi: env.discovery,
+  });
+
   return await createRouter({
-    logger,
-    config,
-    database,
+    logger: env.logger,
+    config: env.config,
+    database: env.database,
+    reader: env.reader,
     catalogClient,
-    reader,
   });
 }

packages/create-app/templates/default-app/packages/backend/src/plugins/search.ts.hbs

@@ -10,42 +10,44 @@ import { PgSearchEngine } from '@backstage/plugin-search-backend-module-pg';
 import { PluginEnvironment } from '../types';
 import { DefaultCatalogCollatorFactory } from '@backstage/plugin-catalog-backend';
 import { DefaultTechDocsCollatorFactory } from '@backstage/plugin-techdocs-backend';
+import { Router } from 'express';
 
-export default async function createPlugin({
-  logger,
-  permissions,
-  discovery,
-  config,
-  tokenManager,
-}: PluginEnvironment) {
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
   // Initialize a connection to a search engine.
   {{#if dbTypeSqlite}}
-  const searchEngine = new LunrSearchEngine({ logger });
+  const searchEngine = new LunrSearchEngine({
+    logger: env.logger,
+  });
   {{/if}}
   {{#if dbTypePG}}
-  const searchEngine = (await PgSearchEngine.supported(database))
-    ? await PgSearchEngine.from({ database })
-    : new LunrSearchEngine({ logger });
+  const searchEngine = (await PgSearchEngine.supported(env.database))
+    ? await PgSearchEngine.from({ database: env.database })
+    : new LunrSearchEngine({ logger: env.logger });
   {{/if}}
-  const indexBuilder = new IndexBuilder({ logger, searchEngine });
+  const indexBuilder = new IndexBuilder({
+    logger: env.logger,
+    searchEngine,
+  });
 
   // Collators are responsible for gathering documents known to plugins. This
   // collator gathers entities from the software catalog.
   indexBuilder.addCollator({
     defaultRefreshIntervalSeconds: 600,
-    factory: DefaultCatalogCollatorFactory.fromConfig(config, {
-      discovery,
-      tokenManager,
+    factory: DefaultCatalogCollatorFactory.fromConfig(env.config, {
+      discovery: env.discovery,
+      tokenManager: env.tokenManager,
     }),
   });
 
   // collator gathers entities from techdocs.
   indexBuilder.addCollator({
     defaultRefreshIntervalSeconds: 600,
-    factory: DefaultTechDocsCollatorFactory.fromConfig(config, {
-      discovery,
-      logger,
-      tokenManager,
+    factory: DefaultTechDocsCollatorFactory.fromConfig(env.config, {
+      discovery: env.discovery,
+      logger: env.logger,
+      tokenManager: env.tokenManager,
     }),
   });
 
@@ -61,8 +63,8 @@ export default async function createPlugin({
   return await createRouter({
     engine: indexBuilder.getSearchEngine(),
     types: indexBuilder.getDocumentTypes(),
-    permissions,
-    config,
-    logger,
+    permissions: env.permissions,
+    config: env.config,
+    logger: env.logger,
   });
 }

packages/create-app/templates/default-app/packages/backend/src/plugins/techdocs.ts

@@ -9,17 +9,13 @@ import Docker from 'dockerode';
 import { Router } from 'express';
 import { PluginEnvironment } from '../types';
 
-export default async function createPlugin({
-  logger,
-  config,
-  discovery,
-  reader,
-  cache,
-}: PluginEnvironment): Promise<Router> {
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
   // Preparers are responsible for fetching source files for documentation.
-  const preparers = await Preparers.fromConfig(config, {
-    logger,
-    reader,
+  const preparers = await Preparers.fromConfig(env.config, {
+    logger: env.logger,
+    reader: env.reader,
   });
 
   // Docker client (conditionally) used by the generators, based on techdocs.generators config.
@@ -27,17 +23,17 @@ export default async function createPlugin({
   const containerRunner = new DockerContainerRunner({ dockerClient });
 
   // Generators are used for generating documentation sites.
-  const generators = await Generators.fromConfig(config, {
-    logger,
+  const generators = await Generators.fromConfig(env.config, {
+    logger: env.logger,
     containerRunner,
   });
 
   // Publisher is used for
   // 1. Publishing generated files to storage
   // 2. Fetching files from storage and passing them to TechDocs frontend.
-  const publisher = await Publisher.fromConfig(config, {
-    logger,
-    discovery,
+  const publisher = await Publisher.fromConfig(env.config, {
+    logger: env.logger,
+    discovery: env.discovery,
   });
 
   // checks if the publisher is working and logs the result
@@ -47,9 +43,9 @@ export default async function createPlugin({
     preparers,
     generators,
     publisher,
-    logger,
-    config,
-    discovery,
-    cache,
+    logger: env.logger,
+    config: env.config,
+    discovery: env.discovery,
+    cache: env.cache,
   });
 }

plugins/airbrake/README.md

@@ -60,13 +60,12 @@ The Airbrake plugin provides connectivity between Backstage and Airbrake (https:
      extractAirbrakeConfig,
    } from '@backstage/plugin-airbrake-backend';
 
-   export default async function createPlugin({
-     logger,
-     config,
-   }: PluginEnvironment): Promise<Router> {
+   export default async function createPlugin(
+     env: PluginEnvironment,
+   ): Promise<Router> {
      return createRouter({
-       logger,
-       airbrakeConfig: extractAirbrakeConfig(config),
+       logger: env.logger,
+       airbrakeConfig: extractAirbrakeConfig(env.config),
      });
    }
    ```

plugins/app-backend/README.md

@@ -18,7 +18,7 @@ Now add the plugin router to your app, creating it for example like this:
 
 ```ts
 const router = await createRouter({
-  logger,
+  logger: env.logger,
   appPackageName: 'example-app',
 });
 ```

plugins/azure-devops-backend/README.md

@@ -43,11 +43,13 @@ Here's how to get the backend up and running:
    import { Router } from 'express';
    import type { PluginEnvironment } from '../types';
 
-   export default function createPlugin({
-     logger,
-     config,
-   }: PluginEnvironment): Promise<Router> {
-     return createRouter({ logger, config });
+   export default function createPlugin(
+     env: PluginEnvironment,
+   ): Promise<Router> {
+     return createRouter({
+       logger: env.logger,
+       config: env.config,
+     });
    }
    ```
 

plugins/badges-backend/README.md

@@ -20,15 +20,15 @@ import {
   createRouter,
   createDefaultBadgeFactories,
 } from '@backstage/plugin-badges-backend';
+import { Router } from 'express';
 import { PluginEnvironment } from '../types';
 
-export default async function createPlugin({
-  config,
-  discovery,
-}: PluginEnvironment) {
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
   return await createRouter({
-    config,
-    discovery,
+    config: env.config,
+    discovery: env.discovery,
     badgeFactories: createDefaultBadgeFactories(),
   });
 }

plugins/bazaar-backend/README.md

@@ -19,13 +19,16 @@ You'll need to add the plugin to the router in your `backend` package. You can d
 ```tsx
 import { PluginEnvironment } from '../types';
 import { createRouter } from '@backstage/plugin-bazaar-backend';
+import { Router } from 'express';
 
-export default async function createPlugin({
-  logger,
-  database,
-  config,
-}: PluginEnvironment) {
-  return await createRouter({ logger, config, database });
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
+  return await createRouter({
+    logger: env.logger,
+    config: env.config,
+    database: env.database,
+  });
 }
 ```
 

plugins/catalog-backend-module-msgraph/README.md

@@ -117,8 +117,8 @@ useHotCleanup(
 ```typescript
 // packages/backend/src/plugins/catalog.ts
 builder.addProcessor(
-  MicrosoftGraphOrgReaderProcessor.fromConfig(config, {
-    logger,
+  MicrosoftGraphOrgReaderProcessor.fromConfig(env.config, {
+    logger: env.logger,
   }),
 );
 ```
@@ -173,8 +173,8 @@ export async function myGroupTransformer(
 
 ```ts
 builder.addProcessor(
-  MicrosoftGraphOrgReaderProcessor.fromConfig(config, {
-    logger,
+  MicrosoftGraphOrgReaderProcessor.fromConfig(env.config, {
+    logger: env.logger,
     groupTransformer: myGroupTransformer,
   }),
 );

plugins/jenkins-backend/README.md

@@ -31,17 +31,17 @@ import { CatalogClient } from '@backstage/catalog-client';
 import { Router } from 'express';
 import { PluginEnvironment } from '../types';
 
-export default async function createPlugin({
-  logger,
-  config,
-  discovery,
-}: PluginEnvironment): Promise<Router> {
-  const catalog = new CatalogClient({ discoveryApi: discovery });
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
+  const catalog = new CatalogClient({
+    discoveryApi: env.discovery,
+  });
 
   return await createRouter({
-    logger,
+    logger: env.logger,
     jenkinsInfoProvider: DefaultJenkinsInfoProvider.fromConfig({
-      config,
+      config: env.config,
       catalog,
     }),
   });

plugins/kafka/README.md

@@ -18,13 +18,16 @@ In a new file named `kafka.ts` under `backend/src/plugins`:
 
 ```js
 import { createRouter } from '@backstage/plugin-kafka-backend';
+import { Router } from 'express';
 import { PluginEnvironment } from '../types';
 
-export default async function createPlugin({
-  logger,
-  config,
-}: PluginEnvironment) {
-  return await createRouter({ logger, config });
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
+  return await createRouter({
+    logger: env.logger,
+    config: env.config,
+  });
 }
 ```
 

plugins/scaffolder-backend-module-cookiecutter/README.md

@@ -22,7 +22,7 @@ Configure the action:
 const actions = [
   createFetchCookiecutterAction({
     integrations,
-    reader,
+    reader: env.reader,
     containerRunner,
   }),
   ...createBuiltInActions({
@@ -32,12 +32,12 @@ const actions = [
 
 return await createRouter({
   containerRunner,
-  logger,
-  config,
-  database,
   catalogClient,
-  reader,
   actions,
+  logger: env.logger,
+  config: env.config,
+  database: env.database,
+  reader: env.reader,
 });
 ```
 

plugins/scaffolder-backend-module-rails/README.md

@@ -26,19 +26,19 @@ see all options):
 const actions = [
   createFetchRailsAction({
     integrations,
-    reader,
+    reader: env.reader,
     containerRunner,
   }),
 ];
 
 return await createRouter({
   containerRunner,
-  logger,
-  config,
-  database,
   catalogClient,
-  reader,
   actions,
+  logger: env.logger,
+  config: env.config,
+  database: env.database,
+  reader: env.reader,
 });
 ```
 

plugins/scaffolder-backend-module-yeoman/README.md

@@ -23,21 +23,21 @@ const actions = [
   createRunYeomanAction(),
   ...createBuiltInActions({
     containerRunner,
-    integrations,
-    config,
     catalogClient,
-    reader,
+    integrations,
+    config: env.config,
+    reader: env.reader,
   }),
 ];
 
 return await createRouter({
   containerRunner,
-  logger,
-  config,
-  database,
   catalogClient,
-  reader,
   actions,
+  logger: env.logger,
+  config: env.config,
+  database: env.database,
+  reader: env.reader,
 });
 ```
 

plugins/tech-insights-backend-module-jsonfc/README.md

@@ -21,14 +21,14 @@ and modify the `techInsights.ts` file to contain a reference to the FactCheckers
 
 +const myFactCheckerFactory = new JsonRulesEngineFactCheckerFactory({
 +   checks: [],
-+   logger,
++   logger: env.logger,
 +}),
 
  const builder = buildTechInsightsContext({
-   logger,
-   config,
-   database,
-   discovery,
+   logger: env.logger,
+   config: env.config,
+   database: env.database,
+   discovery: env.discovery,
    factRetrievers: [myFactRetrieverRegistration],
 +  factCheckerFactory: myFactCheckerFactory
  });
@@ -40,7 +40,7 @@ By default this implementation comes with an in-memory storage to store checks.
  const myTechInsightCheckRegistry: TechInsightCheckRegistry<MyCheckType> = // snip
  const myFactCheckerFactory = new JsonRulesEngineFactCheckerFactory({
    checks: [],
-   logger,
+   logger: env.logger,
 +  checkRegistry: myTechInsightCheckRegistry
  }),
 
@@ -95,7 +95,7 @@ json-rules-engine supports a limited [number of built-in operators](https://gith
 
 const myFactCheckerFactory = new JsonRulesEngineFactCheckerFactory({
    checks: [],
-   logger,
+   logger: env.logger,
 +  operators: [ new Operator("startsWith", (a, b) => a.startsWith(b) ]
 })
 ```

plugins/tech-insights-backend/README.md

@@ -27,24 +27,21 @@ import {
 import { Router } from 'express';
 import { PluginEnvironment } from '../types';
 
-export default async function createPlugin({
-  logger,
-  config,
-  discovery,
-  database,
-}: PluginEnvironment): Promise<Router> {
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
   const builder = buildTechInsightsContext({
-    logger,
-    config,
-    database,
-    discovery,
+    logger: env.logger,
+    config: env.config,
+    database: env.database,
+    discovery: env.discovery,
     factRetrievers: [], // Fact retrievers registrations you want tech insights to use
   });
 
   return await createRouter({
     ...(await builder),
-    logger,
-    config,
+    logger: env.logger,
+    config: env.config,
   });
 }
 ```
@@ -103,10 +100,10 @@ To register these fact retrievers to your application you can modify the example
 
 ```diff
 const builder = new DefaultTechInsightsBuilder({
-  logger,
-  config,
-  database,
-  discovery,
+  logger: env.logger,
+  config: env.config,
+  database: env.database,
+  discovery: env.discovery,
 - factRetrievers: [],
 + factRetrievers: [myFactRetrieverRegistration],
 });
@@ -118,10 +115,10 @@ Current logic on running scheduled fact retrievers is intended to be executed in
 
 ```diff
 const builder = new DefaultTechInsightsBuilder({
-  logger,
-  config,
-  database,
-  discovery,
+  logger: env.logger,
+  config: env.config,
+  database: env.database,
+  discovery: env.discovery,
 - factRetrievers: [],
 + factRetrievers: process.env.MAIN_FACT_RETRIEVER_INSTANCE ? [myFactRetrieverRegistration] : [],
 });
@@ -210,14 +207,14 @@ and modify the `techInsights.ts` file to contain a reference to the FactChecker
 
 +const myFactCheckerFactory = new JsonRulesEngineFactCheckerFactory({
 +   checks: [],
-+   logger,
++   logger: env.logger,
 +}),
 
  const builder = new DefaultTechInsightsBuilder({
-   logger,
-   config,
-   database,
-   discovery,
+   logger: env.logger,
+   config: env.config,
+   database: env.database,
+   discovery: env.discovery,
    factRetrievers: [myFactRetrieverRegistration],
 +  factCheckerFactory: myFactCheckerFactory
  });
@@ -233,7 +230,7 @@ The default FactChecker implementation comes with an in-memory storage to store
 const myTechInsightCheckRegistry: TechInsightCheckRegistry<MyCheckType> = // snip
 const myFactCheckerFactory = new JsonRulesEngineFactCheckerFactory({
   checks: [],
-  logger,
+  logger: env.logger,
 + checkRegistry: myTechInsightCheckRegistry
 }),
 

plugins/todo-backend/README.md

@@ -16,17 +16,18 @@ import {
 } from '@backstage/plugin-todo-backend';
 import { PluginEnvironment } from '../types';
 
-export default async function createPlugin({
-  logger,
-  reader,
-  config,
-  discovery,
-}: PluginEnvironment): Promise<Router> {
-  const todoReader = TodoScmReader.fromConfig(config, {
-    logger,
-    reader,
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
+  const todoReader = TodoScmReader.fromConfig(env.config, {
+    logger: env.logger,
+    reader: env.reader,
   });
-  const catalogClient = new CatalogClient({ discoveryApi: discovery });
+
+  const catalogClient = new CatalogClient({
+    discoveryApi: discovery,
+  });
+
   const todoService = new TodoReaderService({
     todoReader,
     catalogClient,
@@ -66,9 +67,9 @@ import {
 
 // ...
 
-const todoReader = TodoScmReader.fromConfig(config, {
-  logger,
-  reader,
+const todoReader = TodoScmReader.fromConfig(env.config, {
+  logger: env.logger,
+  reader: env.reader,
   parser: createTodoParser({
     additionalTags: ['NOTE', 'XXX'],
   }),

plugins/todo/README.md

@@ -26,17 +26,18 @@ import {
 } from '@backstage/plugin-todo-backend';
 import { PluginEnvironment } from '../types';
 
-export default async function createPlugin({
-  logger,
-  reader,
-  config,
-  discovery,
-}: PluginEnvironment): Promise<Router> {
-  const todoReader = TodoScmReader.fromConfig(config, {
-    logger,
-    reader,
+export default async function createPlugin(
+  env: PluginEnvironment,
+): Promise<Router> {
+  const todoReader = TodoScmReader.fromConfig(env.config, {
+    logger: env.logger,
+    reader: env.reader,
   });
-  const catalogClient = new CatalogClient({ discoveryApi: discovery });
+
+  const catalogClient = new CatalogClient({
+    discoveryApi: env.discovery,
+  });
+
   const todoService = new TodoReaderService({
     todoReader,
     catalogClient,