When is the appropriate time to provide arguments to the constructor of a TypeScript service?

Question

When is the appropriate time to provide arguments to the constructor of a TypeScript service?

I am grappling with the concept of when to pass arguments to a service's constructor versus passing them in the execution of the service.

For instance, I have a service that filters rows from an Excel sheet:

@Injectable()
export class FilterRowsService {
  private rows: AvailablesLogWithDate[];

  constructor(rows: AvailablesLogWithDate[]) {
    this.rows = rows;
  }

  execute({
    descriptions,
    products,
    warehouse,
    dates,
  }: {
    dates?: Dates;
    descriptions?: string[];
    products?: string[];
    warehouse?: string;
  } = {}) {
    this.filterByDates({ dates });
    this.filterByProducts({ products });
    this.filterByDescriptions({ descriptions });
    this.filterByWarehouse({ warehouse });

    return this.rows;
  }

  private filterByWarehouse({ warehouse }: { warehouse: string }) {
    if (!warehouse) {
      return this.rows;
    }

    this.rows = this.rows.filter((row) => {
      const warehouseInfo = warehousesInfos[warehouse];
      const warehouseKeywords = warehouseInfo.availableKeyWords;

      return warehouseKeywords.includes(row.Location);
    });
  }

I have various filtering methods that modify the state of the rows. I opted to pass the rows to the constructor and create a class variable so I wouldn't have to repeatedly pass the rows in each filtering method. However, I'm hesitant about altering the state of the rows directly. Perhaps it's acceptable since it only happens within the class.

Alternatively, the second approach would involve not having a class variable for rows, passing them to the execute method, and implementing something like this:

@Injectable()
export class FilterRowsService {
  execute({
    rows,
    descriptions,
    products,
    warehouse,
    dates,
  }: {
    rows: AvailablesLogWithDate[];
    dates?: Dates;
    descriptions?: string[];
    products?: string[];
    warehouse?: string;
  }) {
    let filteredRows = rows;
    filteredRows = this.filterByWarehouse({ warehouse, rows });
    filteredRows = this.filterByDates({ dates, rows });
    flteredRows = this.filterByProducts({ products, rows });
    filteredRows = this.filterByDescriptions({ descriptions, rows });

    return filteredRows;
  }

  private filterByWarehouse({
    warehouse,
    rows,
  }: {
    warehouse: string;
    rows: AvailablesLogWithDate[];
  }) {
    if (!warehouse) {
      return rows;
    }

    return rows.filter((row) => {
      const warehouseInfo = warehousesInfos[warehouse];
      const warehouseKeywords = warehouseInfo.availableKeyWords;

      return warehouseKeywords.includes(row.Location);
    });
  }

In this scenario, each filtering method produces a new filteredRows variable, which then gets updated after every filtering method in the execute function, ensuring the initial rows are never mutated.

The second approach appears more scalable and proper, but I'm curious if the first approach has any merit and, if not, why that is.

javascript typescript constructor domain-driven-design

Answer 1

Answer №1

Uncertain about the connection to DDD, but regardless...

In most cases, passing arguments in the constructor is suitable when the dependencies have the same lifecycle as the object being created. On the other hand, method arguments are preferred when the dependencies are only necessary for a specific use case. Additionally, it is advised that services remain stateless for easier comprehension, reusability, and thread safety.

Although JavaScript doesn't place a strong emphasis on thread safety, it seems cumbersome for the client code to repeatedly instantiate a new service just to filter rows. Moreover, Angular services maintain singleton behavior within their injection context, making the constructor(rows) approach even less feasible.

I realize the desire to remove the need to pass around rows while keeping the service stateless.

One option is to create a separate class to manage the filtering process. By abstracting this as an implementation detail, the service class can remain stateless.

class FilterRowsService {
    filter(rows, ...) {
        return new FilterProcess(rows, ...).execute();
    }
}

Utilize closures to encapsulate rows. Although this may result in functions being recreated, the performance impact should be negligible in this scenario.

class FilterRowService {
    filter(rows, ...) {
        filterByWarehouse();
        filterByDates();
        
        return rows;

        function filterByWarehouse() {
            rows = rows.filter(...)
        }

        function filterByDates() {
            rows = rows.filter(...)
        }
    }
}

Combine filters into a single unit or chain them together. By focusing solely on predicates, there's no need to pass rows around. This approach also minimizes iterating over rows multiple times by constructing a composite predicate encompassing all conditions. The warehouseFilter and datesFilter functions can serve as factories for (row) => boolean predicates.

class FilterRowsService {
    filter(rows, ...) {
        const compositePredicate = [warehouseFilter(warehouse), datesFilter(dates), ...]
            .reduce((a, b) => row => a(row) && b(row));
 
        return rows.filter(compositePredicate);
    }
}

Here's an example demonstrating this concept:

class SomeFilterService {
    filter(items, text, color) {
        return items.filter(this._composePredicates(
            this._textIncludes(text),
            this._colorIs(color)
        ));
    }
    
    _composePredicates(...predicates) {
        return predicates.reduce((a, b) => item => a(item) && b(item));
    }

    _textIncludes(text) {
        return item => item.text.includes(text);
    }
    
    _colorIs(color) {
        return item => item.color === color;
    }
}

const items = new SomeFilterService().filter([
  { text: 'hello', color: 'blue' }, 
  { text: 'test', color: 'blue' }, { text: 'test', color: 'red' 
 }], 'test', 'blue');

console.log(items);

If the service primarily focuses on composing predicates, consider employing the Builder pattern instead for filter composition.

This response aims to provide adequate guidance and alternatives for making informed design choices to address your issue.

Answer 2

Uncertain about the connection to DDD, but regardless...

In most cases, passing arguments in the constructor is suitable when the dependencies have the same lifecycle as the object being created. On the other hand, method arguments are preferred when the dependencies are only necessary for a specific use case. Additionally, it is advised that services remain stateless for easier comprehension, reusability, and thread safety.

Although JavaScript doesn't place a strong emphasis on thread safety, it seems cumbersome for the client code to repeatedly instantiate a new service just to filter rows. Moreover, Angular services maintain singleton behavior within their injection context, making the constructor(rows) approach even less feasible.

I realize the desire to remove the need to pass around rows while keeping the service stateless.

One option is to create a separate class to manage the filtering process. By abstracting this as an implementation detail, the service class can remain stateless.

class FilterRowsService {
    filter(rows, ...) {
        return new FilterProcess(rows, ...).execute();
    }
}

Utilize closures to encapsulate rows. Although this may result in functions being recreated, the performance impact should be negligible in this scenario.

class FilterRowService {
    filter(rows, ...) {
        filterByWarehouse();
        filterByDates();
        
        return rows;

        function filterByWarehouse() {
            rows = rows.filter(...)
        }

        function filterByDates() {
            rows = rows.filter(...)
        }
    }
}

Combine filters into a single unit or chain them together. By focusing solely on predicates, there's no need to pass rows around. This approach also minimizes iterating over rows multiple times by constructing a composite predicate encompassing all conditions. The warehouseFilter and datesFilter functions can serve as factories for (row) => boolean predicates.

class FilterRowsService {
    filter(rows, ...) {
        const compositePredicate = [warehouseFilter(warehouse), datesFilter(dates), ...]
            .reduce((a, b) => row => a(row) && b(row));
 
        return rows.filter(compositePredicate);
    }
}

Here's an example demonstrating this concept:

class SomeFilterService {
    filter(items, text, color) {
        return items.filter(this._composePredicates(
            this._textIncludes(text),
            this._colorIs(color)
        ));
    }
    
    _composePredicates(...predicates) {
        return predicates.reduce((a, b) => item => a(item) && b(item));
    }

    _textIncludes(text) {
        return item => item.text.includes(text);
    }
    
    _colorIs(color) {
        return item => item.color === color;
    }
}

const items = new SomeFilterService().filter([
  { text: 'hello', color: 'blue' }, 
  { text: 'test', color: 'blue' }, { text: 'test', color: 'red' 
 }], 'test', 'blue');

console.log(items);

If the service primarily focuses on composing predicates, consider employing the Builder pattern instead for filter composition.

This response aims to provide adequate guidance and alternatives for making informed design choices to address your issue.

When is the appropriate time to provide arguments to the constructor of a TypeScript service?

Answer №1

Similar questions

Unable to call Success function in JQuery AJAX request

What is the best way to establish a model using a date index?

Is there a way to refresh the page in NextJs whenever the parameters are modified without the need for reloading?

The use of history.pushState in Chrome triggers a request for the favicon

Attempting to Retrieve Information from a Get Request using Axios

Utilizing the [mat-dialog-close] directive within an Angular dialog component

Error occurs in ASP.NET AJAX Control Toolkit while uploading files within Scriptresource.axd

Looking for regex to extract dynamic category items in node.js

I am unable to refresh the table data in Angular

What is the best way to make a drop down menu list appear when I click on the parent li, and then show the sub li using JavaScript?

What is preventing me from using property null checking to narrow down types?

Can a function be passed as props in a scenario where both a Parent and Child component are functional components?

What is the functionality of the remote data source in Jquery Mobile autocomplete feature?

Promise not being properly returned by io.emit

Having difficulty sending emails with Nodemailer

Converting (Geo)JSON data into an array of objects

Jenkins encountered an issue where script execution was blocked on <URL> due to the document's frame being sandboxed without the 'allow-scripts' permission set

Discovering the ReturnType in Typescript when applied to functions within functions

Re-establishing connections in the force-directed graph model

Vuejs Error: "No template or render function defined for a single file component"