Simple tool to transpile DTO classes used in WebAPI action methods to TypeScript.

MIT

nTsMapper is published as a nuget package https://www.nuget.org/packages/nTsMapper. You can install the pacakge from the package manager console with the following command: Install-Package nTsMapper

This application will inspect the specified .NET dll for WebAPI controller methods to produce TypeScript code for all the command parameter and DTO classes used.

Command Line Parameters: [-assemblypath] [-outputfilename] [-help] [-debug]

nTsMapper is able to find all the classes used as parameters in query or command API methods through reflection. For example:

public HttpResponseMessage DeleteCustomer(CustomerCommandParameter commandParameter)

In this example the CustomerCommandParameter parameter will be detected and a corresponding ICustomerCommandParameter interface and a CustomerCommandParameter class will be produced.

In order for nTsMapper to find classes used in API method responses, they must be included in a ReponseType attribute on the method where they are used. For example:

[ResponseType(typeof(CustomerDeleteResult))]
public HttpResponseMessage DeleteCustomer(CustomerCommandParameter commandParameter)
{
	return Request.CreateResponse(HttpStatusCode.OK, new CustomerDeleteResult());
}

In this example, nTsMapper will find both the CustomerDeleteResult and the CustomerCommandParameter classes.

Note: the ResponseType attribute is declared in WebAPI 2.0 and higher in System.Web.Http.Description.

If multiple ResponseType attributes are specified, the first class will be considered the success case and any subsequent classes will be treated as error casses. For example:

[ResponseType(typeof(CustomerDeleteResult))]
[ResponseType(typeof(CustomerErrorDTO))]
public HttpResponseMessage DeleteCustomer(CustomerCommandParameter commandParameter)

At present, the success and error information is not being utilized, but may be used in future release.

Important things to point out about the generated TypeScript:

• An Interface and a Class are produced for each source .NET class
• Each TypeScript class has a fromJSON method
• Each interface/class combination is exported in a module name based on the class's original namespace.

nTsMapper produces both an interface and a class for each source class to provide maximum flexibility client side.

The interface definition is provided for situations when you need to implement the interface in a separate class.

Class definitions are provided for use all over the client side including for example creating services that handle GET, SEND, or POST requests. For example:

getCustomer = (customerId: string): IPromise<WebApi.Models.Customers.ICustomerDashboardDTO> => {
	var deferred = this._q.defer();
	var apiUrl = this._baseApiUrl + 'getCustomer?customerId=' + customerId;

	this._http({ method: 'GET', url: apiUrl })
		.success((data: any) => {
			var response = WebApi.Models.Customers.fromJSON(data);
			deferred.resolve(response);
		})
		.error((data, status) => {
			var result = { status: status, errorMessage: "An error occurred. Please try again." };
			deferred.reject(result);
		});

	return deferred.promise;
};

The fromJSON method allows the client side user to get the JSON data from a GET method, for example, and easily convert it into an instance of the corresponding TypeScript class with all the properties filled out.

var response = WebApi.Models.Customers.fromJSON(data);

nTsMapper places the generated TypeScript interface and class definition in their own module based on the namespace of the source class. In many cases, this will result in multiple modules of the same name; however this allows nTsMapper to produce TypeScript code with class hierarchies that will be correctly interpreted by the JavaScript compiler.

module WebApi.Models.Customers {
	export interface ICustomerDeleteResult   {
	}
	export class CustomerDeleteResult  implements ICustomerDeleteResult {
		public static fromJSON(json: any) : CustomerDeleteResult {
			if (json === undefined)
				return undefined;
			if (json === null)
				return null;

			return {

			};
		}
	}
}

module WebApi.Models.Customers {
	export interface ICustomerCommandParameter   {
		id: string;
	}
	export class CustomerCommandParameter  implements ICustomerCommandParameter {
		id: string;
		public static fromJSON(json: any) : CustomerCommandParameter {
			if (json === undefined)
				return undefined;
			if (json === null)
				return null;

			return {
				id: json.id
			};
		}
	}
}

module WebApi.Models.Customers {
	export interface ICustomerDashboardDTO   {
		firstName: string;
		lastName: string;
		gender: string;
		id: string;
	}
	export class CustomerDashboardDTO  implements ICustomerDashboardDTO {
		firstName: string;
		lastName: string;
		gender: string;
		id: string;
		public static fromJSON(json: any) : CustomerDashboardDTO {
			if (json === undefined)
				return undefined;
			if (json === null)
				return null;

			return {
				firstName: json.firstName,
				lastName: json.lastName,
				gender: json.gender,
				id: json.id
			};
		}
	}
}

None