The correlation of types between function parameters using function overloads in TypeScript

Question

The correlation of types between function parameters using function overloads in TypeScript

In the process of developing a factory function, I am incorporating a type argument to specify the type of object being created, along with a parameter argument containing parameters that describe the object. The parameters are dependent on the specific type of object being created. An example of this is shown below:

enum EntityType {
  TABLE,
  BUCKET
}
type TableParams = { tableName: string }
type BucketParams = { bucketName: string }

function createEntity (type: EntityType.TABLE, params: TableParams): void
function createEntity (type: EntityType.BUCKET, params: BucketParams): void
function createEntity (type: EntityType, params: TableParams | BucketParams): void {
  switch(type) {
    case EntityType.TABLE:
      console.log('table name:', params.tableName)
      break
    case EntityType.BUCKET:
      console.log('bucket name:', params.bucketName)
      break
  }
}

The use of function overloads ensures that users can only invoke the function with the appropriate parameters based on the entity type, for example:

createEntity(EntityType.TABLE, { tableName: 'foo' })
createEntity(EntityType.BUCKET, { bucketName: 'bar' })
createEntity(EntityType.BUCKET, { tableName: 'fox' }) // => No overload matches this call.

The first two calls execute successfully, however, the third call results in a compilation error stating "No overload matches this call."

Yet how can I enforce type safety within the function? In other words, the provided sample does not compile because of the message "Property 'tableName' does not exist on type 'TableParams | BucketParams'."

Isn't TypeScript supposed to infer the type of the params argument based on which of the two function overloads is matched?

typescript

Answer 1

Answer №1

To eliminate the need for an enum and avoid using a typeguard, you can combine all parameters within one interface type.

interface EntityData {
    type: { new( ...args : any ) : BaseEntity };
    // Add shared member params
}

interface TableData extends EntityData {
    type: typeof TableEntity;
    tableName: string;
}

interface BucketData extends EntityData {
    type: typeof BucketEntity;
    bucketName: string;
}

class BaseEntity {
    constructor( data : EntityData ) {
        //assign any shared member params here
    }
}

class TableEntity extends BaseEntity {
    public tableName : string;

    constructor( data : TableData ) {
        super(data);
        this.tableName = data.tableName;
        console.log('table name:',this.tableName);
    }
}

class BucketEntity extends BaseEntity {
    public bucketName : string;

    constructor( data : BucketData ) {
        super(data);
        this.bucketName = data.bucketName;
        console.log('bucket name:', params.bucketName);
    }
}

function createEntity( data: TableData ): BaseEntity | undefined;
function createEntity( data: BucketData ): BaseEntity | undefined;
function createEntity( data: EntityData ): BaseEntity | undefined {
    if ( data ) {
        return new data.type(data );
    }
    return undefined;
}

createEntity( { type : TableEntity, tableName : 'foo'});

A more type-safe approach is to use it as follows:

let myTableData : TableData = { 
    type: TableEntity,
    tableName : 'foo'
}

createEntity( myTableData );

// The above will compile
// The below 2 examples will result in compile errors

let myTableData2 : TableData = { 
    type: BucketEntity,
    tableName : 'foo'
} // Will give type error for BucketEntity here

let myTableData3 : TableData = {
    type: TableEntity,
    bucketName : 'foo'
}  // Will give error here for bucketName not existing in TableData

If you still want to use overloads, consider implementing a typeguard inside the switch statement for proper typing

enum EntityType {
  TABLE,
  BUCKET
}
type TableParams = { tableName: string }
type BucketParams = { bucketName: string }

function createEntity (type: EntityType.TABLE, params: TableParams): void
function createEntity (type: EntityType.BUCKET, params: BucketParams): void
function createEntity (type: EntityType, params: TableParams | BucketParams): void {
  switch(type) {
    case EntityType.TABLE:
        if( paramsAreTableParams( params ) ) {
            console.log('table name:', params.tableName);
        } else {
            console.log('incorrect params');
        }
        break;
    case EntityType.BUCKET:
        if( paramsAreBucketParams( params ) ) {
            console.log('table name:', params.bucketName);
        } else {
            console.log('incorrect params');
        }
        break;
  }
}

function paramsAreTableParams( params : TableParams | BucketParams ) : params is TableParams {
    return ( params as TableParams).tableName != undefined;
}

function paramsAreBucketParams( params : TableParams | BucketParams ) : params is BucketParams {
    return ( params as BucketParams).bucketName != undefined;
}

Answer 2

To eliminate the need for an enum and avoid using a typeguard, you can combine all parameters within one interface type.

interface EntityData {
    type: { new( ...args : any ) : BaseEntity };
    // Add shared member params
}

interface TableData extends EntityData {
    type: typeof TableEntity;
    tableName: string;
}

interface BucketData extends EntityData {
    type: typeof BucketEntity;
    bucketName: string;
}

class BaseEntity {
    constructor( data : EntityData ) {
        //assign any shared member params here
    }
}

class TableEntity extends BaseEntity {
    public tableName : string;

    constructor( data : TableData ) {
        super(data);
        this.tableName = data.tableName;
        console.log('table name:',this.tableName);
    }
}

class BucketEntity extends BaseEntity {
    public bucketName : string;

    constructor( data : BucketData ) {
        super(data);
        this.bucketName = data.bucketName;
        console.log('bucket name:', params.bucketName);
    }
}

function createEntity( data: TableData ): BaseEntity | undefined;
function createEntity( data: BucketData ): BaseEntity | undefined;
function createEntity( data: EntityData ): BaseEntity | undefined {
    if ( data ) {
        return new data.type(data );
    }
    return undefined;
}

createEntity( { type : TableEntity, tableName : 'foo'});

A more type-safe approach is to use it as follows:

let myTableData : TableData = { 
    type: TableEntity,
    tableName : 'foo'
}

createEntity( myTableData );

// The above will compile
// The below 2 examples will result in compile errors

let myTableData2 : TableData = { 
    type: BucketEntity,
    tableName : 'foo'
} // Will give type error for BucketEntity here

let myTableData3 : TableData = {
    type: TableEntity,
    bucketName : 'foo'
}  // Will give error here for bucketName not existing in TableData

If you still want to use overloads, consider implementing a typeguard inside the switch statement for proper typing

enum EntityType {
  TABLE,
  BUCKET
}
type TableParams = { tableName: string }
type BucketParams = { bucketName: string }

function createEntity (type: EntityType.TABLE, params: TableParams): void
function createEntity (type: EntityType.BUCKET, params: BucketParams): void
function createEntity (type: EntityType, params: TableParams | BucketParams): void {
  switch(type) {
    case EntityType.TABLE:
        if( paramsAreTableParams( params ) ) {
            console.log('table name:', params.tableName);
        } else {
            console.log('incorrect params');
        }
        break;
    case EntityType.BUCKET:
        if( paramsAreBucketParams( params ) ) {
            console.log('table name:', params.bucketName);
        } else {
            console.log('incorrect params');
        }
        break;
  }
}

function paramsAreTableParams( params : TableParams | BucketParams ) : params is TableParams {
    return ( params as TableParams).tableName != undefined;
}

function paramsAreBucketParams( params : TableParams | BucketParams ) : params is BucketParams {
    return ( params as BucketParams).bucketName != undefined;
}

The correlation of types between function parameters using function overloads in TypeScript

Answer №1

Similar questions

Tips for effectively overriding a method in typescript

Utilizing epics in conjunction with typesafe-actions and Connected React Router for seamless integration and enhanced

Potential absence of object.ts(2531)

When using nodejs with sqlite3, the first callback parameter returns the class instance. How can this be resolved in order to prevent any issues?

Illustrative demonstration of Vue with TypeScript

What is the reason behind the restriction on using 'this' on the left side of an assignment?

What is the process for importing a TypeScript module from the local directory?

Guide on importing an ES6 package into an Express Typescript Project that is being utilized by a Vite React package

Exploring Angular 2's nested navigation using the latest router technology

Navigating through ionic2 with angularjs2 using for-each loops

What is the best way to implement a generic parameter with constraints in an abstract method?

Compare the values of properties in an array with those in a separate array to filter in Angular/TypeScript

Tips for querying enum data type using GraphQL

Typescript - Specifying the return type for a deeply nested object

Here is a guide on implementing Hash in URLs with React Router

Guide to automatically installing @types for all node modules

Understanding how to deduce parameter types in TypeScript

Type definitions in Typescript for the style property of Animated.View

Color key in square shape for graph legend

How come the splice method is changing the value of the original object?