How to use the typeorm.EntityRepository function in typeorm

To help you get started, we’ve selected a few typeorm examples, based on popular ways it is used in public projects.

Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.

github jmaicaaan / express-starter-ts / src / repositories / roleMapping.repository.ts View on Github external
import { Container } from 'typedi';
import { EntityRepository, Repository } from 'typeorm';

import { Role, RoleMapping, User } from '../entities';
import { RoleRepository } from '../repositories';

@EntityRepository(RoleMapping)
export class RoleMappingRepository extends Repository {

  public async addRoleMapping(user: User, role: Role): Promise {
    try {
      if (role) {
        const roleMapping = new RoleMapping(role, user);
        const savedRoleMapping = await this.save(roleMapping);
        delete savedRoleMapping.user; // remove the user property to avoid circular
        return savedRoleMapping;
      }
    } catch (error) {
      throw error;
    }
  }
}
github Roche / lxdhub / packages / dbsync / src / operating-system / operating-system.repository.ts View on Github external
import { OperatingSystem } from '@lxdhub/db';
import { Connection, EntityRepository, Repository } from 'typeorm';

@EntityRepository(OperatingSystem)
export class OperatingSystemRepository extends Repository { }
github santaz1995 / nestjs-cqrs-starter / src / modules / user / repository / type-orm / type-orm-user.command.repository.ts View on Github external
import { EntityRepository, getManager, SelectQueryBuilder } from 'typeorm';
import { ObjectType } from 'typeorm/common/ObjectType';
import { TypeOrmCommandRepository } from '../../../../common/database/type-orm/type-orm.command.repository';
import { UserCommandRepository } from '../../domain/user.command.repository';
import { User } from '../../domain/user';

@EntityRepository()
export class TypeOrmUserCommandRepository extends TypeOrmCommandRepository implements UserCommandRepository {

    constructor() {
        super(getManager());
    }

    /**
     * @param {number} id
     * @returns {Promise}
     */
    public async byId(id: number): Promise {
        return this.createQueryBuilder().andWhere('u.id = :id').setParameter('id', id).getOne();
    }

    /**
     * @param {User} user
github santaz1995 / nestjs-cqrs-starter / src / infrastructures / domain / typeorm / command / type-orm-project-skill.command.repository.ts View on Github external
import { EntityRepository, getManager, SelectQueryBuilder } from 'typeorm';
import { ObjectType } from 'typeorm/common/ObjectType';
import { TypeOrmCommandRepository } from './type-orm.command.repository';
import { ProjectSkillCommandRepository } from '../../../../domains/project-skill/project-skill.command.repository';
import { ProjectSkill } from '../../../../domains/project-skill/project-skill';

@EntityRepository()
export class TypeOrmProjectSkillCommandRepository extends TypeOrmCommandRepository implements ProjectSkillCommandRepository {

    constructor() {
        super(getManager());
    }

    /**
     * @param {number} id
     * @returns {Promise}
     */
    public async byId(id: number): Promise {
        return this.createQueryBuilder().andWhere('ps.id = :id').setParameter('id', id).getOne();
    }

    /**
     * @param {ProjectSkill} projectSkill
github santaz1995 / nestjs-cqrs-starter / src / modules / project / modules / project-categories / repository / type-orm / type-orm-project-category.query.repository.ts View on Github external
import { EntityRepository, getManager, SelectQueryBuilder } from 'typeorm';
import { ObjectType } from 'typeorm/common/ObjectType';
import { TypeOrmQueryRepository } from '../../../../../../common/database/type-orm/type-orm.query.repository';
import { ProjectCategory } from '../../domain/project-category';
import { ProjectCategoryNotFoundException } from '../../domain/project-category-not-found.exception';

@EntityRepository()
export class TypeOrmProjectCategoryQueryRepository extends TypeOrmQueryRepository implements TypeOrmProjectCategoryQueryRepository {

    constructor() {
        super(getManager('query'));
    }

    /**
     * @returns {Promise}
     */
    public getAll(): Promise {
        return this.createQueryBuilder().getMany();
    }

    /**
     * @param {number} id
     * @returns {Promise}
github Roche / lxdhub / packages / dbsync / src / architecture / architecture.repository.ts View on Github external
import { Architecture } from '@lxdhub/db';
import { Connection, EntityRepository, Repository } from 'typeorm';

@EntityRepository(Architecture)
export class ArchitectureRepository extends Repository { }
github drip-trader / dripjs / modules / models / entity / master-pair / master-pair.repository.ts View on Github external
exchange: MasterPairEntity['exchange'];
  name: MasterPairEntity['name'];
  baseAsset: MasterPairEntity['baseAsset'];
  quoteAsset: MasterPairEntity['quoteAsset'];
  amountPrecision: MasterPairEntity['amountPrecision'];
  pricePrecision: MasterPairEntity['pricePrecision'];
  maxOrderAmount: MasterPairEntity['maxOrderAmount'];
  maxOrderPrice: MasterPairEntity['maxOrderPrice'];
}

export interface PairPrecision {
  amountPrecision: MasterPairEntity['amountPrecision'];
  pricePrecision: MasterPairEntity['pricePrecision'];
}

@EntityRepository(MasterPairEntity)
export class MasterPairRepository extends Repository {
  async findByPair(pair: string): Promise {
    return this.findOne({ where: { name: pair } });
  }

  async insertNewPair(params: MasterPairEntityCreateParams): Promise {
    return this.save(params as MasterPairEntity, { reload: false });
  }

  async insertNewPairs(params: MasterPairEntityCreateParams[]): Promise {
    return this.save(params as MasterPairEntity[], { reload: false });
  }

  async getPrecisionByPair(pair: string): Promise {
    const rs = await this.createQueryBuilder()
      .select('price_precision', 'pricePrecision')
github santaz1995 / nestjs-cqrs-starter / src / infrastructures / domain / typeorm / query / type-orm-feedback.query.repository.ts View on Github external
import { EntityRepository, getManager, SelectQueryBuilder } from 'typeorm';
import { ObjectType } from 'typeorm/common/ObjectType';
import { Feedback } from '../../../../domains/feedback/feedback';
import { TypeOrmQueryRepository } from './type-orm.query.repository';
import { FeedbackQueryRepository } from '../../../../domains/feedback/feedback-query.repository';
import { FeedbackNotFoundException } from '../../../../domains/feedback/feedback-not-found.exception';

@EntityRepository()
export class TypeOrmFeedbackQueryRepository extends TypeOrmQueryRepository implements FeedbackQueryRepository {

    constructor() {
        super(getManager('query'));
    }

    /**
     * @returns {Promise}
     */
    public async getAll(): Promise {
        return this.createQueryBuilder().getMany();
    }

    /**
     * @param {number} id
     * @returns {Promise}
github mgm-interns / team-radio / server / src / repositories / user / UserRepository.ts View on Github external
import { User } from 'entities';
import { UserNotFoundException } from 'exceptions';
import { Logger } from 'services';
import { Inject, Service } from 'typedi';
import { EntityRepository } from 'typeorm';
import { RegisterInput } from 'types';
import { TokenHelper } from 'utils';
import { BaseRepository } from '../BaseRepository';

@Service()
@EntityRepository(User)
export class UserRepository extends BaseRepository {
  @Inject()
  private logger: Logger;

  public async findByUsernameOrEmail({
    username,
    email
  }: {
    username?: string;
    email?: string;
  }): Promise {
    let user;
    if (username) {
      user = await this.findOne({ where: { username } });
    }
    if (email) {
github santaz1995 / nestjs-cqrs-starter / src / infrastructures / domain / typeorm / query / type-orm-project-image.query.repository.ts View on Github external
import { EntityRepository, getManager, SelectQueryBuilder } from 'typeorm';
import { ObjectType } from 'typeorm/common/ObjectType';
import { TypeOrmQueryRepository } from './type-orm.query.repository';
import { ProjectImageQueryRepository } from '../../../../domains/project-image/project-image.query.repository';
import { ProjectImage } from '../../../../domains/project-image/project-image';
import { ProjectImageNotFoundException } from '../../../../domains/project-image/project-image-not-found.exception';

@EntityRepository()
export class TypeOrmProjectImageQueryRepository extends TypeOrmQueryRepository implements ProjectImageQueryRepository {

    constructor() {
        super(getManager('query'));
    }

    /**
     * @returns {Promise}
     */
    public getAll(id: number): Promise {
        return this.createQueryBuilder().andWhere('pi.projectId = :id').setParameter('id', id).getMany();
    }

    /**
     * @param {number} id
     * @returns {Promise}