Merge pull request #31166 from schultzp2020/constructor-parameters

refactor: convert constructor parameter properties for erasableSyntaxOnly compatibility

plugins/scaffolder-backend/src/scaffolder/dryrun/DecoratedActionsRegistry.ts

@@ -21,11 +21,13 @@ import { BackstageCredentials } from '@backstage/backend-plugin-api';
 /** @internal */
 export class DecoratedActionsRegistry implements TemplateActionRegistry {
   private readonly innerActions: Map<string, TemplateAction> = new Map();
+  private readonly innerRegistry: TemplateActionRegistry;
 
   constructor(
-    private readonly innerRegistry: TemplateActionRegistry,
+    innerRegistry: TemplateActionRegistry,
     extraActions: Array<TemplateAction>,
   ) {
+    this.innerRegistry = innerRegistry;
     for (const action of extraActions) {
       this.innerActions.set(action.id, action);
     }

plugins/scaffolder-backend/src/scaffolder/tasks/DatabaseWorkspaceProvider.ts

@@ -19,11 +19,15 @@ import { TaskStore } from './types';
 import { WorkspaceProvider } from '@backstage/plugin-scaffolder-node/alpha';
 
 export class DatabaseWorkspaceProvider implements WorkspaceProvider {
+  private readonly storage: TaskStore;
+
   static create(storage: TaskStore) {
     return new DatabaseWorkspaceProvider(storage);
   }
 
-  private constructor(private readonly storage: TaskStore) {}
+  private constructor(storage: TaskStore) {
+    this.storage = storage;
+  }
 
   public async serializeWorkspace(options: {
     path: string;

plugins/scaffolder-backend/src/scaffolder/tasks/NunjucksWorkflowRunner.ts

@@ -128,8 +128,10 @@ const isActionAuthorized = createConditionAuthorizer(
 
 export class NunjucksWorkflowRunner implements WorkflowRunner {
   private readonly defaultTemplateFilters: Record<string, TemplateFilter>;
+  private readonly options: NunjucksWorkflowRunnerOptions;
 
-  constructor(private readonly options: NunjucksWorkflowRunnerOptions) {
+  constructor(options: NunjucksWorkflowRunnerOptions) {
+    this.options = options;
     this.defaultTemplateFilters = convertFiltersToRecord(
       createDefaultFilters({
         integrations: this.options.integrations,

plugins/scaffolder-backend/src/scaffolder/tasks/StorageTaskBroker.ts

@@ -84,15 +84,29 @@ export class TaskManager implements TaskContext {
     return agent;
   }
 
+  private readonly task: CurrentClaimedTask;
+  private readonly storage: TaskStore;
+  private readonly signal: AbortSignal;
+  private readonly logger: LoggerService;
+  private readonly workspaceService: WorkspaceService;
+  private readonly auth?: AuthService;
+
   // Runs heartbeat internally
   private constructor(
-    private readonly task: CurrentClaimedTask,
-    private readonly storage: TaskStore,
-    private readonly signal: AbortSignal,
-    private readonly logger: LoggerService,
-    private readonly workspaceService: WorkspaceService,
-    private readonly auth?: AuthService,
-  ) {}
+    task: CurrentClaimedTask,
+    storage: TaskStore,
+    signal: AbortSignal,
+    logger: LoggerService,
+    workspaceService: WorkspaceService,
+    auth?: AuthService,
+  ) {
+    this.task = task;
+    this.storage = storage;
+    this.signal = signal;
+    this.logger = logger;
+    this.workspaceService = workspaceService;
+    this.auth = auth;
+  }
 
   get taskId() {
     return this.task.taskId;
@@ -249,17 +263,31 @@ export interface CurrentClaimedTask {
 }
 
 export class StorageTaskBroker implements TaskBroker {
+  private readonly storage: TaskStore;
+  private readonly logger: LoggerService;
+  private readonly config?: Config;
+  private readonly auth?: AuthService;
+  private readonly additionalWorkspaceProviders?: Record<
+    string,
+    WorkspaceProvider
+  >;
+  private readonly auditor?: AuditorService;
+
   constructor(
-    private readonly storage: TaskStore,
-    private readonly logger: LoggerService,
-    private readonly config?: Config,
-    private readonly auth?: AuthService,
-    private readonly additionalWorkspaceProviders?: Record<
-      string,
-      WorkspaceProvider
-    >,
-    private readonly auditor?: AuditorService,
-  ) {}
+    storage: TaskStore,
+    logger: LoggerService,
+    config?: Config,
+    auth?: AuthService,
+    additionalWorkspaceProviders?: Record<string, WorkspaceProvider>,
+    auditor?: AuditorService,
+  ) {
+    this.storage = storage;
+    this.logger = logger;
+    this.config = config;
+    this.auth = auth;
+    this.additionalWorkspaceProviders = additionalWorkspaceProviders;
+    this.auditor = auditor;
+  }
 
   async list(options?: {
     createdBy?: string;

plugins/scaffolder-backend/src/scaffolder/tasks/TaskWorker.ts

@@ -90,11 +90,16 @@ export class TaskWorker {
   private parameterAuditTransform: ParameterAuditTransform;
   private stopWorkers: boolean;
 
+  private readonly options: TaskWorkerOptions & {
+    parameterAuditTransform: ParameterAuditTransform;
+  };
+
   private constructor(
-    private readonly options: TaskWorkerOptions & {
+    options: TaskWorkerOptions & {
       parameterAuditTransform: ParameterAuditTransform;
     },
   ) {
+    this.options = options;
     this.stopWorkers = false;
     this.logger = options.logger;
     this.auditor = options.auditor;

plugins/scaffolder-backend/src/scaffolder/tasks/WorkspaceService.ts

@@ -49,11 +49,19 @@ export class DefaultWorkspaceService implements WorkspaceService {
     return new DefaultWorkspaceService(task, workspaceProvider, config);
   }
 
+  private readonly task: CurrentClaimedTask;
+  private readonly workspaceProvider: WorkspaceProvider;
+  private readonly config?: Config;
+
   private constructor(
-    private readonly task: CurrentClaimedTask,
-    private readonly workspaceProvider: WorkspaceProvider,
-    private readonly config?: Config,
-  ) {}
+    task: CurrentClaimedTask,
+    workspaceProvider: WorkspaceProvider,
+    config?: Config,
+  ) {
+    this.task = task;
+    this.workspaceProvider = workspaceProvider;
+    this.config = config;
+  }
 
   public async serializeWorkspace(options: { path: string }): Promise<void> {
     if (this.isWorkspaceSerializationEnabled()) {

plugins/scaffolder-backend/src/scaffolder/tasks/logger.ts

@@ -44,13 +44,20 @@ interface WinstonLoggerOptions {
 // This is a workaround for being able to preserve the log format of the root logger.
 // Will revisit all of this implementation once we can break the router to use only `LoggerService`.
 export class BackstageLoggerTransport extends Transport {
+  private readonly backstageLogger: LoggerService;
+  private readonly taskContext: TaskContext;
+  private readonly stepId: string;
+
   constructor(
-    private readonly backstageLogger: LoggerService,
-    private readonly taskContext: TaskContext,
-    private readonly stepId: string,
+    backstageLogger: LoggerService,
+    taskContext: TaskContext,
+    stepId: string,
     opts?: TransportStreamOptions,
   ) {
     super(opts);
+    this.backstageLogger = backstageLogger;
+    this.taskContext = taskContext;
+    this.stepId = stepId;
   }
 
   log(info: TransformableInfo, callback: VoidFunction) {

plugins/scaffolder-backend/src/util/loggerToWinstonLogger.ts

@@ -20,11 +20,11 @@ import { Logger as WinstonLogger, createLogger } from 'winston';
 import Transport, { TransportStreamOptions } from 'winston-transport';
 
 class BackstageLoggerTransport extends Transport {
-  constructor(
-    private readonly backstageLogger: LoggerService,
-    opts?: TransportStreamOptions,
-  ) {
+  private readonly backstageLogger: LoggerService;
+
+  constructor(backstageLogger: LoggerService, opts?: TransportStreamOptions) {
     super(opts);
+    this.backstageLogger = backstageLogger;
   }
 
   log(info: unknown, callback: VoidFunction) {