@travetto/cli 8.0.0-alpha.1 → 8.0.0-alpha.3

package/README.md

@@ -558,7 +558,8 @@ $ trv service --help
 Usage: service [options] <action:restart|start|status|stop> [services...:string]
 
 Options:
-  -h, --help  display help for command
+  -q, --quiet   (default: false)
+  -h, --help   display help for command
 
 Available Services
 --------------------

package/__index__.ts

@@ -1,7 +1,6 @@
 import type { } from './src/trv.d.ts';
 export * from './src/types.ts';
 export * from './src/execute.ts';
-export * from './src/error.ts';
 export * from './src/schema.ts';
 export * from './src/schema-export.ts';
 export * from './src/registry/decorator.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/cli",
-  "version": "8.0.0-alpha.1",
+  "version": "8.0.0-alpha.3",
   "type": "module",
   "description": "CLI infrastructure for Travetto framework",
   "keywords": [
@@ -29,8 +29,8 @@
     "directory": "module/cli"
   },
   "dependencies": {
-    "@travetto/schema": "^8.0.0-alpha.1",
-    "@travetto/terminal": "^8.0.0-alpha.1"
+    "@travetto/schema": "^8.0.0-alpha.2",
+    "@travetto/terminal": "^8.0.0-alpha.2"
   },
   "travetto": {
     "displayName": "Command Line Interface",

package/src/execute.ts

@@ -1,9 +1,8 @@
-import { ConsoleManager, getClass, Runtime, ShutdownManager, Util } from '@travetto/runtime';
+import { ConsoleManager, Runtime, ShutdownManager, Util } from '@travetto/runtime';
 
 import { HelpUtil } from './help.ts';
 import { CliCommandRegistryIndex } from './registry/registry-index.ts';
 import { CliCommandSchemaUtil } from './schema.ts';
-import { CliUnknownCommandError, CliValidationResultError } from './error.ts';
 import { CliParseUtil } from './parse.ts';
 import type { CliCommandShape } from './types.ts';
 
@@ -12,73 +11,46 @@ import type { CliCommandShape } from './types.ts';
  */
 export class ExecutionManager {
 
-  /** Error handler */
-  static async #onError(error: unknown): Promise<void> {
-    process.exitCode ??= 1;
-    if (error instanceof CliValidationResultError) {
-      console.error!(HelpUtil.renderValidationError(error));
-      console.error!(await HelpUtil.renderCommandHelp(error.command));
-    } else if (error instanceof CliUnknownCommandError) {
-      if (error.help) {
-        console.error!(error.help);
-      } else {
-        console.error!(error.defaultMessage, '\n');
-        console.error!(await HelpUtil.renderAllHelp(''));
-      }
-    } else {
-      console.error!(error);
-    }
-    console.error!();
-  }
-
-  /** Bind command  */
-  static async #bindCommand(cmd: string, args: string[]): Promise<{ command: CliCommandShape, boundArgs: unknown[] }> {
-    const [{ instance: command, schema }] = await CliCommandRegistryIndex.load([cmd]);
-    const fullArgs = await CliParseUtil.expandArgs(schema, args);
+  /**
+   * Execute the command line
+   * @param args
+   */
+  static async run(argv: string[]): Promise<void> {
+    let command: CliCommandShape | undefined;
 
-    const state = await CliParseUtil.parse(schema, fullArgs);
-    CliParseUtil.setState(command, state);
+    const { cmd, args, help } = CliParseUtil.getArgs(argv);
+    if (!cmd) {
+      return console.info!(await HelpUtil.renderAllHelp());
+    }
 
-    const boundArgs = CliCommandSchemaUtil.bindInput(command, state);
-    return { command, boundArgs };
-  }
+    try {
+      const [{ instance, schema, config }] = await CliCommandRegistryIndex.load([cmd]);
+      command = instance;
+      const fullArgs = await CliParseUtil.expandArgs(schema, args);
 
-  /** Run command */
-  static async #runCommand(cmd: string, args: string[]): Promise<void> {
-    const { command, boundArgs } = await this.#bindCommand(cmd, args);
+      const state = await CliParseUtil.parse(schema, fullArgs);
+      CliParseUtil.setState(instance, state);
 
-    await CliCommandSchemaUtil.validate(command, boundArgs);
-    const config = CliCommandRegistryIndex.get(getClass(command));
+      const boundArgs = CliCommandSchemaUtil.bindInput(instance, state);
+      await instance.finalize?.(help);
 
-    for (const preMain of config.preMain ?? []) {
-      await preMain(command);
-    }
-    await command.finalize?.();
+      if (help) {
+        return console.log!(await HelpUtil.renderCommandHelp(instance));
+      }
 
-    ConsoleManager.debug(Runtime.debug);
-    await command.main(...boundArgs);
-  }
+      await CliCommandSchemaUtil.validate(command, boundArgs);
 
-  /**
-   * Execute the command line
-   * @param args
-   */
-  static async run(argv: string[]): Promise<void> {
-    try {
       // Wait 50ms to allow stdout to flush on shutdown
       ShutdownManager.signal.addEventListener('abort', () => Util.blockingTimeout(50));
 
-      const { cmd, args, help } = CliParseUtil.getArgs(argv);
-      if (!cmd) {
-        console.info!(await HelpUtil.renderAllHelp());
-      } else if (help) {
-        const { command } = await this.#bindCommand(cmd, args);
-        console.log!(await HelpUtil.renderCommandHelp(command));
-      } else {
-        await this.#runCommand(cmd, args);
+      for (const preMain of config.preMain ?? []) {
+        await preMain(instance);
       }
+
+      ConsoleManager.debug(Runtime.debug);
+      await instance.main(...boundArgs);
     } catch (error) {
-      await this.#onError(error);
+      await HelpUtil.renderError(error, cmd, command);
     } finally {
       await ShutdownManager.shutdown();
     }

package/src/help.ts

@@ -1,12 +1,11 @@
 import util from 'node:util';
 
-import { castKey, getClass, JSONUtil } from '@travetto/runtime';
-import { SchemaRegistryIndex } from '@travetto/schema';
+import { castKey, getClass, JSONUtil, Runtime } from '@travetto/runtime';
+import { SchemaRegistryIndex, ValidationResultError } from '@travetto/schema';
 
 import { cliTpl } from './color.ts';
 import type { CliCommandShape } from './types.ts';
-import { CliCommandRegistryIndex } from './registry/registry-index.ts';
-import type { CliValidationResultError } from './error.ts';
+import { CliCommandRegistryIndex, UNKNOWN_COMMAND } from './registry/registry-index.ts';
 import { CliSchemaExportUtil } from './schema-export.ts';
 
 const validationSourceMap: Record<string, string> = {
@@ -17,11 +16,39 @@ const validationSourceMap: Record<string, string> = {
 const ifDefined = <T>(value: T | null | '' | undefined): T | undefined =>
   (value === null || value === '' || value === undefined) ? undefined : value;
 
+const toItem = (name: string, pkg: string, prod?: boolean) => [name, Runtime.getInstallCommand(pkg, prod)] as const;
+
+const INSTALL_COMMANDS = new Map<string, string>([
+  ...['test', 'test:watch', 'test:direct'].map(item => toItem(item, '@travetto/test')),
+  ...['lint', 'lint:register', 'eslint', 'eslint:register'].map(item => toItem(item, '@travetto/eslint')),
+  ...['model:install', 'model:export'].map(item => toItem(item, '@travetto/model', true)),
+  ...['openapi:spec', 'openapi:client'].map(item => toItem(item, '@travetto/openapi', true)),
+  ...['email:compile', 'email:test', 'email:editor'].map(item => toItem(item, '@travetto/email-compiler')),
+  ...['pack', 'pack:zip', 'pack:docker'].map(item => toItem(item, '@travetto/pack')),
+  ...['repo:publish', 'repo:version', 'repo:exec', 'repo:list', 'repo:version-sync'].map(item => toItem(item, '@travetto/repo')),
+  toItem('web:http', '@travetto/web-http', true),
+  toItem('doc', '@travetto/doc'),
+  toItem('web:rpc-client', '@travetto/web-rpc', true),
+]);
+
 /**
  * Utilities for showing help
  */
 export class HelpUtil {
 
+  /** Render the unknown command message */
+  static renderUnknownCommandMessage(cmd: string): string {
+    const install = INSTALL_COMMANDS.get(cmd);
+    if (install) {
+      return cliTpl`
+${{ title: 'Missing Package' }}\n${'-'.repeat(20)}\nTo use ${{ input: cmd }} please run:\n
+${{ identifier: install }}
+`;
+    } else {
+      return cliTpl`${{ subtitle: 'Unknown command' }}: ${{ input: cmd }}`;
+    }
+  }
+
   /**
    * Render command-specific help
    * @param command
@@ -31,8 +58,6 @@ export class HelpUtil {
     const { name: commandName } = CliCommandRegistryIndex.get(getClass(command));
     const args = schema.methods.main?.parameters ?? [];
 
-    await command.finalize?.(true);
-
     // Ensure finalized
 
     const usage: string[] = [cliTpl`${{ title: 'Usage:' }} ${{ param: commandName }} ${{ input: '[options]' }}`,];
@@ -132,7 +157,7 @@ export class HelpUtil {
   /**
    * Render validation error to a string
    */
-  static renderValidationError(validationError: CliValidationResultError): string {
+  static renderValidationError(validationError: ValidationResultError): string {
     return [
       cliTpl`${{ failure: 'Execution failed' }}:`,
       ...validationError.details.errors.map(error => {
@@ -144,4 +169,20 @@ export class HelpUtil {
       '',
     ].join('\n');
   }
+
+  /** Error handler */
+  static async renderError(error: unknown, cmd: string, command?: CliCommandShape): Promise<void> {
+    process.exitCode ??= 1;
+    if (error instanceof ValidationResultError) {
+      console.error!(this.renderValidationError(error));
+    }
+    if (command) {
+      console.error!(await this.renderCommandHelp(command));
+    } else if (error === UNKNOWN_COMMAND) {
+      console.error!(this.renderUnknownCommandMessage(cmd));
+    } else {
+      console.error!(error);
+    }
+    console.error!();
+  }
 }

package/src/registry/registry-index.ts

@@ -3,7 +3,6 @@ import { type RegistryAdapter, type RegistryIndex, RegistryIndexStore, Registry
 import { type SchemaClassConfig, SchemaRegistryIndex } from '@travetto/schema';
 
 import type { CliCommandConfig, CliCommandShape } from '../types.ts';
-import { CliUnknownCommandError } from '../error.ts';
 import { CliCommandRegistryAdapter } from './registry-adapter.ts';
 
 const CLI_FILE_REGEX = /\/cli[.](?<name>.{0,100}?)([.]tsx?)?$/;
@@ -11,6 +10,8 @@ const getName = (field: string): string => (field.match(CLI_FILE_REGEX)?.groups?
 
 type CliCommandLoadResult = { command: string, config: CliCommandConfig, instance: CliCommandShape, schema: SchemaClassConfig };
 
+export const UNKNOWN_COMMAND = Symbol();
+
 export class CliCommandRegistryIndex implements RegistryIndex {
 
   static #instance = Registry.registerIndex(this);
@@ -57,7 +58,7 @@ export class CliCommandRegistryIndex implements RegistryIndex {
    */
   async #getInstance(name: string): Promise<CliCommandShape> {
     if (!this.hasCommand(name)) {
-      throw new CliUnknownCommandError(name);
+      throw UNKNOWN_COMMAND;
     }
 
     if (this.#instanceMapping.has(name)) {
@@ -95,7 +96,7 @@ export class CliCommandRegistryIndex implements RegistryIndex {
       this.#instanceMapping.set(name, result);
       return result;
     }
-    throw new CliUnknownCommandError(name);
+    throw UNKNOWN_COMMAND;
   }
 
   hasCommand(name: string): boolean {

package/src/schema-export.ts

@@ -1,4 +1,4 @@
-import { type Class, describeFunction } from '@travetto/runtime';
+import { castTo, type Class, describeFunction } from '@travetto/runtime';
 import { type SchemaInputConfig, SchemaRegistryIndex } from '@travetto/schema';
 
 import { CliCommandRegistryIndex } from '../src/registry/registry-index.ts';
@@ -9,7 +9,7 @@ import { CliCommandRegistryIndex } from '../src/registry/registry-index.ts';
 export type CliCommandInput<K extends string = string> = {
   name: string;
   description?: string;
-  type: 'string' | 'file' | 'number' | 'boolean' | 'date' | 'regex' | 'module';
+  type: 'string' | 'file' | 'number' | 'bigint' | 'boolean' | 'date' | 'regex' | 'module';
   fileExtensions?: string[];
   choices?: unknown[];
   required?: boolean;
@@ -37,11 +37,12 @@ export class CliSchemaExportUtil {
    * Get the base type for a CLI command input
    */
   static baseInputType(config: SchemaInputConfig): Pick<CliCommandInput, 'type' | 'fileExtensions'> {
-    switch (config.type) {
+    switch (castTo<Function>(config.type)) {
       case Date: return { type: 'date' };
       case Boolean: return { type: 'boolean' };
       case Number: return { type: 'number' };
       case RegExp: return { type: 'regex' };
+      case BigInt: return { type: 'bigint' };
       case String: {
         switch (true) {
           case config.specifiers?.includes('module'): return { type: 'module' };

package/src/schema.ts

@@ -2,7 +2,6 @@ import { castKey, castTo, getClass } from '@travetto/runtime';
 import { BindUtil, SchemaRegistryIndex, SchemaValidator, ValidationResultError, type ValidationError } from '@travetto/schema';
 
 import type { ParsedState, CliCommandShape } from './types.ts';
-import { CliValidationResultError } from './error.ts';
 
 const getSource = (source: string | undefined, defaultSource: ValidationError['source']): ValidationError['source'] => {
   switch (source) {
@@ -15,7 +14,7 @@ const getSource = (source: string | undefined, defaultSource: ValidationError['s
 };
 
 const transformErrors = (source: 'arg' | 'flag', error: unknown): ValidationError[] => {
-  if (error instanceof CliValidationResultError || error instanceof ValidationResultError) {
+  if (error instanceof ValidationResultError) {
     return error.details.errors.map(value => ({ source: getSource(value.source, source), ...value }));
   } else {
     throw error;
@@ -32,16 +31,16 @@ export class CliCommandSchemaUtil {
   /**
    * Bind parsed inputs to command
    */
-  static bindInput<T extends CliCommandShape>(cmd: T, state: ParsedState): unknown[] {
+  static bindInput<T extends CliCommandShape>(command: T, state: ParsedState): unknown[] {
     const template: Partial<T> = {};
     const bound: unknown[] = [];
 
-    for (const arg of state.all) {
-      switch (arg.type) {
+    for (const item of state.all) {
+      switch (item.type) {
         case 'flag': {
-          const key = castKey<T>(arg.fieldName);
-          const value = arg.value!;
-          if (arg.array) {
+          const key = castKey<T>(item.fieldName);
+          const value = item.value!;
+          if (item.array) {
             castTo<unknown[]>(template[key] ??= castTo([])).push(value);
           } else {
             template[key] = castTo(value);
@@ -49,36 +48,36 @@ export class CliCommandSchemaUtil {
           break;
         }
         case 'arg': {
-          if (arg.array) {
-            castTo<unknown[]>(bound[arg.index] ??= []).push(arg.input);
+          if (item.array) {
+            castTo<unknown[]>(bound[item.index] ??= []).push(item.input);
           } else {
-            bound[arg.index] = arg.input;
+            bound[item.index] = item.input;
           }
         }
       }
     }
 
-    const cls = getClass(cmd);
-    BindUtil.bindSchemaToObject(cls, cmd, template);
+    const cls = getClass(command);
+    BindUtil.bindSchemaToObject(cls, command, template);
     return BindUtil.coerceMethodParams(cls, 'main', bound);
   }
 
   /**
    * Validate command shape with the given arguments
    */
-  static async validate(cmd: CliCommandShape, args: unknown[]): Promise<typeof cmd> {
-    const cls = getClass(cmd);
+  static async validate(command: CliCommandShape, args: unknown[]): Promise<typeof command> {
+    const cls = getClass(command);
     const paramNames = SchemaRegistryIndex.get(cls).getMethod('main').parameters.map(config => config.name!);
 
     const results = await Promise.all([
-      SchemaValidator.validate(cls, cmd).then(() => [], transformFlagErrors),
+      SchemaValidator.validate(cls, command).then(() => [], transformFlagErrors),
       SchemaValidator.validateMethod(cls, 'main', args, paramNames).then(() => [], transformArgErrors),
     ]);
 
     const errors = results.flat();
     if (errors.length) {
-      throw new CliValidationResultError(cmd, errors);
+      throw new ValidationResultError(errors);
     }
-    return cmd;
+    return command;
   }
 }

package/src/service.ts

@@ -3,7 +3,7 @@ import fs from 'node:fs/promises';
 import rl from 'node:readline/promises';
 import net from 'node:net';
 
-import { ExecUtil, TimeUtil, Util } from '@travetto/runtime';
+import { ExecUtil, Runtime, RuntimeIndex, TimeUtil, Util } from '@travetto/runtime';
 
 const ports = (value: number | `${number}:${number}`): [number, number] =>
   typeof value === 'number' ?
@@ -36,6 +36,23 @@ export type ServiceAction = 'start' | 'stop' | 'status' | 'restart';
  */
 export class ServiceRunner {
 
+  /**
+   * Find all services
+   */
+  static async findServices(services: string[]): Promise<ServiceDescriptor[]> {
+    return (await Promise.all(
+      RuntimeIndex.find({
+        module: module => module.roles.includes('std'),
+        folder: folder => folder === 'support',
+        file: file => /support\/service[.]/.test(file.sourceFile)
+      })
+        .map(file => Runtime.importFrom<{ service: ServiceDescriptor }>(file.import).then(value => value.service))
+    ))
+      .filter(file => !!file)
+      .filter(file => services?.length ? services.includes(file.name) : true)
+      .toSorted((a, b) => a.name.localeCompare(b.name));
+  }
+
   #descriptor: ServiceDescriptor;
   constructor(descriptor: ServiceDescriptor) { this.#descriptor = descriptor; }
 

package/support/cli.service.ts

@@ -1,13 +1,14 @@
+import { stripVTControlCharacters } from 'node:util';
+
 import { type CliCommandShape, CliCommand, cliTpl } from '@travetto/cli';
 import { Terminal } from '@travetto/terminal';
 import { AsyncQueue, Util } from '@travetto/runtime';
 import { MethodValidator, type ValidationError } from '@travetto/schema';
 
 import { ServiceRunner, type ServiceAction } from '../src/service.ts';
-import { getServices } from './bin/util.ts';
 
-async function validateService(action: ServiceAction, services: string[]): Promise<ValidationError | undefined> {
-  const all = await getServices(services);
+async function validateService(_: ServiceAction, services: string[]): Promise<ValidationError | undefined> {
+  const all = await ServiceRunner.findServices(services);
 
   if (!all.length) {
     return { message: 'No services found', source: 'arg', kind: 'invalid', path: 'services' };
@@ -20,8 +21,10 @@ async function validateService(action: ServiceAction, services: string[]): Promi
 @CliCommand()
 export class CliServiceCommand implements CliCommandShape {
 
+  quiet = false;
+
   async help(): Promise<string[]> {
-    const all = await getServices([]);
+    const all = await ServiceRunner.findServices([]);
     return [
       cliTpl`${{ title: 'Available Services' }}`,
       '-'.repeat(20),
@@ -31,12 +34,14 @@ export class CliServiceCommand implements CliCommandShape {
 
   @MethodValidator(validateService)
   async main(action: ServiceAction, services: string[] = []): Promise<void> {
-    const all = await getServices(services);
+    const all = await ServiceRunner.findServices(services);
     const maxName = Math.max(...all.map(service => service.name.length), 'Service'.length) + 3;
     const maxVersion = Math.max(...all.map(service => `${service.version}`.length), 'Version'.length) + 3;
     const maxStatus = 20;
     const queue = new AsyncQueue<{ idx: number, text: string, done?: boolean }>();
 
+    const failureMessages: string[] = [];
+
     const jobs = all.map(async (descriptor, i) => {
       const identifier = descriptor.name.padEnd(maxName);
       const type = `${descriptor.version}`.padStart(maxVersion - 3).padEnd(maxVersion);
@@ -44,19 +49,33 @@ export class CliServiceCommand implements CliCommandShape {
       for await (const [valueType, value] of new ServiceRunner(descriptor).action(action)) {
         const details = { [valueType === 'message' ? 'subtitle' : valueType]: value };
         queue.add({ idx: i, text: msg = cliTpl`${{ identifier }} ${{ type }} ${details}` });
+        if (valueType === 'failure') {
+          failureMessages.push(msg);
+        }
       }
       queue.add({ idx: i, done: true, text: msg! });
     });
 
     Promise.all(jobs).then(() => Util.queueMacroTask()).then(() => queue.close());
 
-    const term = new Terminal();
-    await term.writer.writeLines([
-      '',
-      cliTpl`${{ title: 'Service'.padEnd(maxName) }} ${{ title: 'Version'.padEnd(maxVersion) }} ${{ title: 'Status' }}`,
-      ''.padEnd(maxName + maxVersion + maxStatus + 3, '-'),
-    ]).commit();
 
-    await term.streamList(queue);
+    if (this.quiet) {
+      for await (const _ of queue) { }
+      if (failureMessages.length) {
+        console.error('Failure');
+        failureMessages.map(stripVTControlCharacters).map(item => console.error(item));
+      }
+    } else {
+      const term = new Terminal();
+      await term.writer.writeLines([
+        '',
+        cliTpl`${{ title: 'Service'.padEnd(maxName) }} ${{ title: 'Version'.padEnd(maxVersion) }} ${{ title: 'Status' }}`,
+        ''.padEnd(maxName + maxVersion + maxStatus + 3, '-'),
+      ]).commit();
+
+      await term.streamList(queue);
+    }
+
+    process.exitCode = failureMessages.length ? 1 : 0;
   }
 }

package/src/error.ts

@@ -1,59 +0,0 @@
-import { RuntimeError, Runtime } from '@travetto/runtime';
-import type { ValidationError } from '@travetto/schema';
-
-import { cliTpl } from './color.ts';
-import type { CliCommandShape } from './types.ts';
-
-const COMMAND_PACKAGE = [
-  [/^test(:watch)?$/, 'test', false],
-  [/^lint(:register)?$/, 'eslint', false],
-  [/^model:(install|export)$/, 'model', true],
-  [/^openapi:(spec|client)$/, 'openapi', true],
-  [/^email:(compile|editor)$/, 'email-compiler', false],
-  [/^pack(:zip|:docker)?$/, 'pack', false],
-  [/^web:http$/, 'web-http', true],
-  [/^web:rpc-client$/, 'web-rpc', true],
-] as const;
-
-/**
- * Provides a contract for unknown commands
- */
-export class CliUnknownCommandError extends Error {
-
-  #getMissingCommandHelp(cmd: string): string | undefined {
-    const matchedConfig = COMMAND_PACKAGE.find(([regex]) => regex.test(cmd));
-    if (matchedConfig) {
-      const [, pkg, production] = matchedConfig;
-      const install = Runtime.getInstallCommand(`@travetto/${pkg}`, production);
-      return cliTpl`
-${{ title: 'Missing Package' }}\n${'-'.repeat(20)}\nTo use ${{ input: cmd }} please run:\n
-${{ identifier: install }}
-`;
-    }
-  }
-
-  help?: string;
-  cmd: string;
-
-  constructor(cmd: string) {
-    super(`Unknown command: ${cmd}`);
-    this.cmd = cmd;
-    this.help = this.#getMissingCommandHelp(cmd);
-  }
-
-  get defaultMessage(): string {
-    return cliTpl`${{ subtitle: 'Unknown command' }}: ${{ input: this.cmd }}`;
-  }
-}
-
-/**
- * Provides a basic error wrapper for cli validation issues
- */
-export class CliValidationResultError extends RuntimeError<{ errors: ValidationError[] }> {
-  command: CliCommandShape;
-
-  constructor(command: CliCommandShape, errors: ValidationError[]) {
-    super('', { details: { errors } });
-    this.command = command;
-  }
-}

package/support/bin/util.ts

@@ -1,16 +0,0 @@
-import { RuntimeIndex, Runtime } from '@travetto/runtime';
-import type { ServiceDescriptor } from '../../__index__.ts';
-
-export async function getServices(services: string[]): Promise<ServiceDescriptor[]> {
-  return (await Promise.all(
-    RuntimeIndex.find({
-      module: module => module.roles.includes('std'),
-      folder: folder => folder === 'support',
-      file: file => /support\/service[.]/.test(file.sourceFile)
-    })
-      .map(file => Runtime.importFrom<{ service: ServiceDescriptor }>(file.import).then(value => value.service))
-  ))
-    .filter(file => !!file)
-    .filter(file => services?.length ? services.includes(file.name) : true)
-    .toSorted((a, b) => a.name.localeCompare(b.name));
-}