Introduction

TypeORM+ is an ORM that can run in NodeJS, Browser, Cordova, PhoneGap, Ionic, React Native, NativeScript, Expo, and Electron platforms and can be used with TypeScript and JavaScript (ES5, ES6, ES7, ES8).

TypeORM vs TypeORM+

TypeORM+ is a fork of TypeORM. TypeORM+ adds functionality to TypeORM intending to make the

Repository

QueryBuilder

TypeORM+ is intended to replace TypeORM, so any changes in its interface are documented below.

Differences from TypeORM

• Soft Deleting
• Query Scopes
• Convenient Pagination
• Conditional Clauses

Installation

1. Install the npm package:

   yarn add typeorm-plus --save

2. You need to install

   reflect-metadata

   shim, node typing, a database driver and so on. You can read more from here: http://typeorm.io.

Getting Started

After installed the npm packages, you can import modules from "typeorm-plus". But if you are using the third-party modules for TypeORM, such like nestjs/typeorm, you need to install

typeorm-plus

typeorm

yarn add [email protected]:typeorm-plus --save

Soft Deleting

1. Including Soft Deleted Entities

In addition to actually removing records from your database, TypeORM+ supports "soft delete". When entities are soft deleted, they are not actually removed from your database. Instead, an attribute that records the delete time is set on the entity and inserted into the database. If the attribute is a non-null value, the entity has been soft deleted. To enable soft deletes for an entity, use the

@DeleteDateColumn

import { DeleteDateColumn } from 'typeorm-plus'

export class Entity {
@DeleteDateColumn({ name: 'deleted_at' })
public deletedAt: Date
}

2. Applying Soft Delete To QueryBuilder

@DeleteDateColumn

import {createConnection} from "typeorm-plus";
import {Entity} from "./entity";

createConnection(/.../).then(async connection => {
await connection
  .getRepository(Entity)
  .createQueryBuilder()
  .softDelete()

// And You can restore it using restore;
await connection
  .getRepository(Entity)
  .createQueryBuilder()
  .restore()
}).catch(error => console.log(error));

3. Applying Soft Delete To Repository

import {createConnection} from "typeorm-plus";
import {Entity} from "./entity";

createConnection(/.../).then(async connection => {
const repository = connection.getRepository(Entity);

// Delete a entity
await repository.softDelete(1);

// And You can restore it using restore;
await repository.restore(1);

// Or You can soft-delete them using softRemove
const entities = await repository.find();
const entitiesAfterSoftRemove = await repository.softRemove(entities);

// And You can recover them using recover;
await repository.recover(entitiesAfterSoftRemove);
}).catch(error => console.log(error));

4. Cascading Soft Deletes

This example show what the cascading soft deletes behaves in TypeORM+.

const category1 = new Category();
category1.name = "animals";

const category2 = new Category();
category2.name = "zoo";
const question = new Question();
question.categories = [category1, category2];
const newQuestion =  await connection.manager.save(question);
await connection.manager.softRemove(newQuestion);

As you can see in this example we did not call

save

softRemove

cascade

import {Entity, PrimaryGeneratedColumn, Column, ManyToMany, JoinTable} from "typeorm-plus";
import {Category} from "./Category";

@Entity()
export class Question {
@PrimaryGeneratedColumn()
id: number;

@ManyToMany(type => Category, category => category.questions, {
    cascade: true
})
@JoinTable()
categories: Category[];
}

Query Scopes

Query scopes allow you to add constraints to all queries for a given entity. You can register scopes in your entity:

1. Registering Scopes

import { DeleteDateColumn } from 'typeorm-plus'

export class Entity {
static scope = {
  'default': {
    deletedAt: IsNull()
  },
  'myScope': {
    deletedAt: Not(IsNull())
  }
}
}

2. Applying Scopes To QueryBuilder

When you are calling

queryBuilder

import {createConnection} from "typeorm-plus";
import {Entity} from "./entity";

createConnection(/.../).then(async connection => {
const repository = connection.getRepository(Entity);
await repository.createQueryBuilder().setScope("myScope").getMany();
}).catch(error => console.log(error));

The param

scope

3. Applying Scopes To Repository

When you are calling

repository

repository

find

findOne

findOneOrFail

count

findByIds

findAndCount

createConnection(/.../).then(async connection => {

const repository = connection.getRepository(Entity);
// Delete a entity
await repository.find({
    scope: 'myScope'
});

}).catch(error => console.log(error)); ``

The property

4. Working with Soft Delete

TypeORM's own soft delete functionality utilizes global scopes to only pull "non-deleted" entities from the database.

If the

@DeleteDateColumn

Convenient Pagination

TypeORM+'s paginator is integrated with the

query builder

repository

1. Paginating Query Builder Results

In this example, the arguments passed to the paginate method is the current page number and the number of items you would like displayed "per page": ```TypeScript import {createConnection} from "typeorm-plus"; import {Entity} from "./entity";

createConnection(/.../).then(async connection => {

await connection .getRepository(Entity) .createQueryBuilder() .paginate(1, 15) .getMany();

}).catch(error => console.log(error));

TypeORM+'s paginator also supports `raw` mode:

createConnection(/.../).then(async connection => {

await connection .getRepository(Entity) .createQueryBuilder() .paginateRaw(1, 15) .getRawMany();

}).catch(error => console.log(error)); ```

2. Paginating Repository Results

You may also paginate queries with the

repository

import {createConnection} from "typeorm-plus";
import {Entity} from "./entity";

createConnection(/.../).then(async connection => {
  await connection
    .getRepository(Entity)
    .findAndCount({
      current: 1,
      size: 15
    })
}).catch(error => console.log(error));

The property

current

size

Conditional Clauses

Sometimes you may want clauses to apply to a query only when something else is true. For instance, you may only want to apply a where statement if a given input value is present on the incoming request. You may accomplish this using the when method:

import {createConnection} from "typeorm-plus";
import {Entity} from "./entity";

createConnection(/.../).then(async connection => {
  await connection
    .getRepository(Entity)
    .createQueryBuilder("it")
    .when(true, qb => qb.where('it.id = 1'))
    .getMany();
}).catch(error => console.log(error));

The when method only executes the given Closure when the first parameter is true. If the first parameter is false, the Closure will not be executed.

License

TypeORM+ is MIT licensed.