Typescript: How to avoid repeating object declaration as a parameter?

Question

Motivation

I would liked to use object as a function parameter. This allow the caller to clearly define the arguments with the field names specified making reviews easier.

Problem

However, this is not very nice to deal with if you use implements and extends. This is what I am doing now.

src/domain/ServiceInterface.ts

export interface ServiceInterface {
  doesThings(args: {
    awesomeFieldName: string;
    isThisAwesomeFieldName?: string;
    ohWaitMoreAwesomeFieldName?: string;
  }): boolean;

src/domain/ComposedServiceInterface.ts

import { ServiceInterface } from "./domain/ServiceInterface";
export type ComposedServiceInterface = ServiceInterface & { hello: () => string };

src/implementations/ComposedServiceImplementation.ts

import { ComposedServiceInterface } from "./domain/ComposedServiceInterface";
export class ComposedServiceImplementation implements ComposedServiceInterface {
  doesThings(args: {
    awesomeFieldName: string;
    isThisAwesomeFieldName?: string;
    ohWaitMoreAwesomeFieldName?: string;
  }): boolean {
    return true;
  }
}

Attempts

1. Using `type` / `interface` for the object parameter

src/domain/ServiceInterface.ts

export type DoesThingsParameter = {
    awesomeFieldName: string;
    isThisAwesomeFieldName?: string;
    ohWaitMoreAwesomeFieldName?: string;
  };
export interface ServiceInterface {
  doesThings(args: DoesThingsParameter): boolean;

src/domain/ComposedServiceInterface.ts

import { ServiceInterface } from "./domain/ServiceInterface";
export type ComposedServiceInterface = ServiceInterface & { hello: () => string };

src/implementations/ComposedServiceImplementation

import { ComposedServiceInterface } from "./domain/ComposedServiceInterface";
import { DoesThingsParameter } from "./domain/ServiceInterface";
export class ComposedServiceImplementation implements ComposedServiceInterface {
  doesThings(args: DoesThingsParameter): boolean {
    return true;
  }
}

Gripe: I don't like this implemetation because src/implementations/ComposedServiceImplementation should not need to import from src/domain/ServiceInterface since it only implements ComposedServiceInterface

2. Using `Parameter` Utility Type

ref: https://www.typescriptlang.org/docs/handbook/utility-types.html#parameterstype

I can't seem to get typescript to agree using a Class method e.g. Parameter<ComposedServiceInterface.doesThings>

Can someone offer any advice?

aditya81070 · Accepted Answer · 2021-08-05 04:34:48Z

1

The correct way of reusing types/interfaces is Attemp#1. Whenever you need to reuse some type definitions, you can extract it out. If you are concerned about importing from src/domain/ServiceInterface in src/implementations/ComposedServiceImplementation, you can always create a common file for types and add common types there and import in both of the files.

The one point to notice here is that you are only importing types from src/domain/ServiceInterface so this import will be cleaned away after you compile your TS code. If you want to know whether you are importing a type of a value, you can use type only import like: import type { DoesThingsParameter } from "./domain/ServiceInterface"; This will give your code more readability.

About Attemp#2, Try to avoid using complex utility types like Parameter or ConstructorParameter too frequently as their implementation is quite complex and Typescript has to do a lot of work. These types are generally used to get types for args for which you don't have access directly. For example, if you are using a library that doesn't ship typescript definitions and you want to use a function from this library.

// some-library.ts
export function configure({
 config1 = 'somevalue',
 retries = 1
}) {
  ...code
}

Now you want to use this configure function but want to create a configuration object outside.

// helper.ts
import { configure } from 'some-lib';

const configuration = {
 config1: 'overrideValue',
 unknownProperty: 'unknownValue'
}
function helper() {
 const lib = configure(configuration)
...some work here
 }

Now, the configuration has all the properties that the configure function needs but it has added one new property that doesn't exist in configure args. In this case, you have to use ParameterType to get the type definition of configure args.

edited Aug 5, 2021 at 4:34

answered Aug 5, 2021 at 4:29

aditya81070

7361 gold badge6 silver badges24 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Alex Wayne Over a year ago

I don't think Typescript allows inferring types from an implements clause. So you have to make it match, or have a type error. Related: stackoverflow.com/questions/58256115/…

Collectives™ on Stack Overflow

Typescript: How to avoid repeating object declaration as a parameter?

Motivation

Problem

Attempts

1. Using `type` / `interface` for the object parameter

2. Using `Parameter` Utility Type

1 Answer 1

1 Comment

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

Motivation

Problem

Attempts

1. Using type / interface for the object parameter

2. Using Parameter Utility Type

1 Answer 1

1 Comment

Your Answer

Sign up or log in

Post as a guest

Linked

Related

1. Using `type` / `interface` for the object parameter

2. Using `Parameter` Utility Type