feat(*): add dependency injection utils

Author: MarcScheib

dist/index.js

@@ -1 +1 @@
-export * from './command.js';
+export * from './init.js';

src/commands/init/command.ts

@@ -1,4 +1,5 @@
-import { initConfig } from '../../config.js';
+import { Command, Option } from 'commander';
+import { CONFIG, initConfig } from '../../config.js';
 import { TemplatesAccess, UseCaseRunner } from '../../services/index.js';
 import {
   hasUserInput,
@@ -7,9 +8,17 @@ import {
   promptTextInput,
 } from '../../shared/index.js';
 import {
+  inject,
+  Injector,
   isExistingWorkspace,
   resolveWorkspacePath,
 } from '../../utils/index.js';
+import { workspacePathArgument } from '../arguments.js';
+
+const templatesRepository = new Option(
+  '--templates-repository <templatesRepository>',
+  'use a template repository'
+);
 
 interface InitActionOptions {
   templatesRepository: OptionInput;
@@ -37,7 +46,7 @@ async function promptTemplateRepository(
     : null;
 }
 
-export async function init(
+export async function initAction(
   workspacePathRaw: string,
   options: InitActionOptions
 ): Promise<void> {
@@ -63,11 +72,19 @@ export async function init(
 
   // init config
   const config = initConfig(workspacePath, organization, templatesRepository);
+  inject(Injector).register(CONFIG, () => config.store);
 
   // copy templates from package/repo to workspace
-  const templatesAccess = TemplatesAccess.create(config.store);
+  const templatesAccess = inject(TemplatesAccess);
   await templatesAccess.initWorkspace();
 
-  const useCaseRunner = UseCaseRunner.create(templatesAccess);
+  const useCaseRunner = inject(UseCaseRunner);
   await useCaseRunner.run('init');
 }
+
+export const init = new Command()
+  .name('init')
+  .description('initialize the workspace')
+  .addArgument(workspacePathArgument)
+  .addOption(templatesRepository)
+  .action(initAction);

src/commands/init/index.ts

@@ -1,9 +1,10 @@
 import { Command, Option } from 'commander';
-import { loadWorkspaceConfig } from '../../config.js';
-import { TemplatesAccess, UseCaseRunner } from '../../services/index.js';
+import { CONFIG, loadWorkspaceConfig } from '../../config.js';
+import { UseCaseRunner } from '../../services/index.js';
 import { UseCasesRepository } from '../../services/use-cases.repository.js';
 import { promptEntitySelection } from '../../shared/entity-selection-prompt.js';
 import { OptionInput } from '../../shared/index.js';
+import { inject, Injector } from '../../utils/index.js';
 import { defaultWorkspacePathArgument } from '../arguments.js';
 
 const useCaseOption = new Option(
@@ -22,9 +23,10 @@ export async function runAction(
   options: RunActionOptions
 ) {
   const config = await loadWorkspaceConfig(workspacePathRaw, options.debug);
-  const templatesAccess = TemplatesAccess.create(config);
-  const useCaseRunner = UseCaseRunner.create(templatesAccess);
-  const useCaseRepository = UseCasesRepository.create(templatesAccess);
+  inject(Injector).register(CONFIG, () => config);
+
+  const useCaseRunner = inject(UseCaseRunner);
+  const useCaseRepository = inject(UseCasesRepository);
 
   const useCases = await useCaseRepository.loadUseCases('INITIAL');
   const useCase = await promptEntitySelection(

src/commands/init/action.ts src/commands/init/init.tssrc/commands/init/action.ts renamed to src/commands/init/init.ts

@@ -1,14 +1,17 @@
 import { Command } from 'commander';
-import { loadWorkspaceConfig } from '../../config.js';
+import { CONFIG, loadWorkspaceConfig } from '../../config.js';
 import { TemplatesAccess, UseCaseRunner } from '../../services/index.js';
+import { inject, Injector } from '../../utils/index.js';
 import { defaultWorkspacePathArgument } from '../arguments.js';
 
 async function syncAction(workspacePathRaw: string): Promise<void> {
   const config = await loadWorkspaceConfig(workspacePathRaw);
-  const templatesAccess = TemplatesAccess.create(config);
-  await templatesAccess.syncTemplates();
+  inject(Injector).register(CONFIG, () => config);
+
+  const templatesAccess = inject(TemplatesAccess);
+  const useCaseRunner = inject(UseCaseRunner);
 
-  const useCaseRunner = UseCaseRunner.create(templatesAccess);
+  await templatesAccess.syncTemplates();
   await useCaseRunner.run('sync');
 }
 

src/commands/run/run.ts

@@ -1,8 +1,10 @@
 import Conf from 'conf';
 import {
   getWorkspacePathIdentifier,
+  inject,
+  InjectionToken,
   isExistingWorkspace,
-  logger,
+  Logger,
   resolveWorkspacePath,
 } from './utils/index.js';
 
@@ -12,6 +14,8 @@ export interface Config {
   templatesRepository: string | null;
 }
 
+export const CONFIG = new InjectionToken<Config>('Config');
+
 export type WorkspaceConfig = Conf<Config>;
 
 const schema = {
@@ -63,7 +67,7 @@ export async function loadWorkspaceConfig(
 ): Promise<Config> {
   const workspacePath = workspacePathRaw.trim();
   if (debug) {
-    logger.log('Running within non-workspace directory...');
+    inject(Logger).log('Running within non-workspace directory...');
     return loadBlankConfig(workspacePath);
   }
 

src/commands/sync/sync.ts

@@ -2,16 +2,36 @@
 import { Command } from 'commander';
 import packageJson from '../package.json';
 import { init, run, sync } from './commands/index.js';
-import { logger } from './utils/index.js';
+import {
+  TemplatesAccess,
+  UseCaseRunner,
+  UseCasesRepository,
+} from './services/index.js';
+import { RepositoriesRepository } from './services/repositories.repository.js';
+import { ScriptExecutor } from './services/script-executor.js';
+import { ServersRepository } from './services/servers.repository.js';
+import { ContextCreator } from './services/use-cases/context-creator.js';
+import { DefaultInjector, inject, Logger } from './utils/index.js';
 
 const handleSigTerm = () => process.exit(0);
 process.on('SIGINT', handleSigTerm);
 process.on('SIGTERM', handleSigTerm);
 process.on('uncaughtException', err => {
-  logger.error(err.message);
+  inject(Logger).error(err.message);
   process.exit(1);
 });
 
+DefaultInjector.getInstance([
+  [Logger, { factory: () => new Logger() }],
+  [ScriptExecutor, { factory: () => new ScriptExecutor() }],
+  [TemplatesAccess, { factory: () => new TemplatesAccess() }],
+  [RepositoriesRepository, { factory: () => new RepositoriesRepository() }],
+  [ServersRepository, { factory: () => new ServersRepository() }],
+  [UseCasesRepository, { factory: () => new UseCasesRepository() }],
+  [ContextCreator, { factory: () => new ContextCreator() }],
+  [UseCaseRunner, { factory: () => new UseCaseRunner() }],
+]);
+
 new Command()
   .name(packageJson.name)
   .description(packageJson.description)
@@ -21,7 +41,7 @@ new Command()
   .addCommand(sync)
   .parseAsync()
   .catch(err => {
-    logger.error(err.message);
+    inject(Logger).error(err.message);
     process.exit(1);
   })
-  .finally(() => logger.success('Finished execution.'));
+  .finally(() => inject(Logger).success('Finished execution.'));

src/config.ts

@@ -1,6 +1,6 @@
 import { join } from 'node:path';
-import { Config } from '../../config.js';
-import { copyDirectory, gitUpdate, logger } from '../../utils/index.js';
+import { CONFIG } from '../../config.js';
+import { copyDirectory, gitUpdate, inject, Logger } from '../../utils/index.js';
 import {
   DIR_CONFIG,
   DIR_DEVELOPMENT,
@@ -19,11 +19,8 @@ enum Location {
 }
 
 export class TemplatesAccess {
-  static create(config: Config): TemplatesAccess {
-    return new TemplatesAccess(config);
-  }
-
-  constructor(private readonly config: Config) {}
+  logger = inject(Logger);
+  config = inject(CONFIG);
 
   getPackageTemplatesDir(): string {
     return join(this.#getBaseDir(Location.PACKAGE), DIR_TEMPLATES);
@@ -92,7 +89,7 @@ export class TemplatesAccess {
   async syncTemplates(): Promise<void> {
     // always sync the templates from the package
     const templatesDirPackage = this.getPackageTemplatesDir();
-    logger.log(`Syncing templates from ${templatesDirPackage}...`);
+    this.logger.log(`Syncing templates from ${templatesDirPackage}...`);
     await copyDirectory(templatesDirPackage, this.getWorkspacePath());
     // sync the templates from the repository
     await this.syncRepositoryTemplates();
@@ -103,7 +100,7 @@ export class TemplatesAccess {
     const templatesRepository = this.getTemplatesRepository();
     if (templatesRepository) {
       const url = this.createRepositoryUrl(templatesRepository);
-      logger.log(`Syncing templates from repository ${url}...`);
+      this.logger.log(`Syncing templates from repository ${url}...`);
 
       await gitUpdate(url, this.getWorkspacePath(), this.getGitTemplatesDir());
       await copyDirectory(this.getGitTemplatesDir(), this.getConfigDir(), [

src/index.ts

@@ -1,7 +1,8 @@
 import { vol } from 'memfs';
 import { temporaryDirectory } from 'tempy';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { initConfig } from '../config.js';
+import { CONFIG, initConfig } from '../config.js';
+import { DefaultInjector, inject, Logger } from '../utils/index.js';
 import { TemplatesAccess } from './access/templates-access.js';
 import { RepositoriesRepository } from './repositories.repository.js';
 
@@ -15,7 +16,14 @@ describe('RepositoriesRepository', () => {
   beforeEach(() => {
     const config = initConfig(path, 'acme', null).store;
 
-    sut = RepositoriesRepository.create(TemplatesAccess.create(config));
+    DefaultInjector.getInstance([
+      [CONFIG, { factory: () => config }],
+      [Logger, { factory: () => new Logger() }],
+      [TemplatesAccess, { factory: () => new TemplatesAccess() }],
+      [RepositoriesRepository, { factory: () => new RepositoriesRepository() }],
+    ]);
+
+    sut = inject(RepositoriesRepository);
   });
 
   it('should load repositories; empty list', async () => {