Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/airtoxin/chimney-ts

Type safe object transformation in TypeScript
https://github.com/airtoxin/chimney-ts

Last synced: about 9 hours ago
JSON representation

Type safe object transformation in TypeScript

Awesome Lists containing this project

README

        

# Chimney-ts

[![Travis](https://img.shields.io/travis/airtoxin/chimney-ts.svg)](https://travis-ci.org/airtoxin/chimney-ts)
[![Donate](https://img.shields.io/badge/donate-paypal-blue.svg)](https://paypal.me/airtoxin)

Type safe object transformation in TypeScript.
This project was heavily inspired from https://github.com/scalalandio/chimney

## Usage

```typescript
import { Chimney } from "chimney-ts";

const square = { size: 10 };
type Rect = { width: number, height: number };

const incompleteRect = new Chimney(square)
.into()
.withFieldRenamed("size", "width");
// Can't call `transform()` because `height` property not filled
// incompleteRect.transform()

const completeRect = incompleteRect
.withFieldRenamed("size", "height")
.transform();
// Square transforms into Rect
```

Also transforms from Array or Promise

```typescript
new Chimney([square])
.into()
.withFieldRenamed("size", "width")
.withFieldRenamed("size", "height")
.transform(); // -> Rect[]

new Chimney(Promise.resolve(square))
.into()
.withFieldRenamed("size", "width")
.withFieldRenamed("size", "height")
.transform(); // -> Promise
```

## API

### Chimney

Creates new chimney transformer.

```typescript
import { Chimney } from "chimney-ts";
const transformer = new Chimney(fromObj).into();
```

__type constraints__

+ `fromObj` value must extends `{} | {}[] | Promise<{}>` type.
+ `Into` type must extends `{}` type.

### Transformer#withFieldConst

Creates new transformer that fills constantValue at fieldName.

```typescript
transformer
.withFieldConst("width", 10)
.withFieldConst("height", 10)
```

Compatible code:
+ Non-monadic: `{ ...fromObj, [intoFieldName]: constValue }`
+ Array: `fromObj.map(el => ({ ...el, [intoFieldName]: constValue }))`
+ Promise: `fromObj.then(el => ({ ...el, [intoFieldName]: constValue }))`

__arguments & type constraints__

+ intoFieldName: `keyof Into` type.
+ constValue: value that extends type of `Into`

### Transformer#withFieldRenamed

Creates new transformer that renames field.

```typescript
transformer
.withFieldRenamed("size", "width")
.withFieldRenamed("size", "height")
```

Compatible code:
+ Non-monadic: `{ ...fromObj, [intoFieldName]: fromObj[fromFieldName] }`
+ Array: `fromObj.map(el => ({ ...el, [intoFieldName]: fromObj[fromFieldName] }))`
+ Promise: `fromObj.then(el => ({ ...el, [intoFieldName]: fromObj[fromFieldName] }))`

__arguments & type constraints__

+ fromFieldName: `keyof From` type.
+ intoFieldName: `keyof Into` type & `From` equals to `Into`

### Transformer#withFieldComputed

Creates new transformer that fills computed value at fieldName.

```typescript
transformer
.withFieldComputed("width", fromObj => fromObj.size * 10)
.withFieldComputed("height", fromObj => fromObj.size * 10)
```

Compatible code:
+ Non-monadic: `{ ...fromObj, [intoFieldName]: computeFn(fromObj) }`
+ Array: `fromObj.map(el => ({ ...fromObj, [intoFieldName]: computeFn(fromObj) }))`
+ Promise: `fromObj.then(el => ({ ...fromObj, [intoFieldName]: computeFn(fromObj) }))`

__arguments & type constraints__

+ intoFieldName: `keyof Into` type
+ computeFn(fromObj): function that returns value that extends `Into` type

### Transformer#transform

Returns transformed value that has `Into` type (or `Into[] | Promise`).
If transformer is not compatible with Into type, method can't call!

```typescript
transformer.transform()
```

## Changelog

### v1.2.0

+ Support Array and Promise transformation

### v1.0.2

+ Fix bug of type definitions

### v1.0.0

+ Initial release