How to use typeorm-typedi-extensions - 10 common examples

import {Container, Service} from "typedi";
import {Connection} from "typeorm";
import {InjectConnection} from "typeorm-typedi-extensions";
import {User} from "../../entity/User";
import {UserEpisode} from "../../entity/UserEpisode";
import {UserMetaData} from "../../entity/UserMetaData";
import * as path from "path";
import * as fs from "fs";
import AppGlobal from "../helpers/AppGlobal";

@Service()
export class UserRepository {

    @InjectConnection("reading")
    private connection: Connection;

    public getAllUsers() {
        const userRepo = this.connection.manager.getRepository(User);
        return userRepo.find();
    }

    public getUser(id) {
        console.log("find user by id", id);
        const userRepo = this.connection.manager.getRepository(User);
        return userRepo.findOne(id);
    }

    public createUser(payload: User) {
        console.log(payload);
        const userRepo = this.connection.manager.getRepository(User);

import {MetaData} from "../../entity/MetaData";
import RoRest from "../services/RoRest";
import {HTMLElement, parse} from "node-html-parser";
import {TorrentFile} from "../../entity/TorrentFile";
import {IMediaEntry} from "../../common/models/IMediaEntry";
import * as ptn from "../../common/lib/parse-torrent-name";
import {MediaRepository} from "./MediaRepository";
import IMDBController from "../controllers/IMDBController";
import {Alias} from "../../entity/Alias";

type TorrentLinks = Array<{title: string, magnet: string, timestamp: number}>;

@Service()
export class TorrentsRepository {

    @InjectConnection("reading")
    private connection: Connection;

    public static startTorrentsWatch(): void {
        setInterval(() => {
            const d = new Date();
            const minutes = d.getMinutes();
            const hours = d.getHours();
            if (hours === 18 && minutes >= 15 && minutes < 45) {
                Container.get(TorrentsRepository).reprocessTorrents()
                    .catch(console.error);
            }
        }, 1800 * 1000);
    }

    public async getAllTorrents() {
        const metaRepo = this.connection.manager.getRepository(MetaData);

import {Container, Service} from "typedi";
import {Connection} from "typeorm";
import {InjectConnection} from "typeorm-typedi-extensions";
import {Genre} from "../../entity/Genre";
import {MetaData} from "../../entity/MetaData";
import MediaController from "../controllers/MediaController";

@Service()
export class GenreRepository {

    @InjectConnection("reading")
    private connection: Connection;

    public getAllGenres() {
        const userRepo = this.connection.manager.getRepository(Genre);
        return userRepo.find();
    }

    public async reprocessAllGenres() {
        const metaRepo = this.connection.manager.getRepository(MetaData);
        const allMeta = await metaRepo.find();
        let allGenres: string[] = [];
        if (allMeta) {
            for (const meta of allMeta) {
                if (meta && meta.genres) {
                    const genres = meta.genres.split(", ") as string[];
                    if (genres) {

constructor(
    @InjectRepository(Message)
    private messageRepository: MongoRepository,
    @InjectRepository(Room) private roomRepository: MongoRepository,
    @InjectRepository(User) private userRepository: MongoRepository,
  ) {}

import { processWebhooks } from '../../../utils/processWebhooks';
import { UserMetaRepository } from '../repositories/UserMetaRepository';
import { UserRepository } from '../repositories/UserRepository';
import { ConnectionArgs, createConnectionType } from '../types/createConnectionType';
import { UpdateUserInput } from '../types/UpdateUserInput';
import { Authorized } from '../utils/Authorized';
import { ExtendedConnection } from '../utils/ExtendedConnection';

const UserConnection = createConnectionType(User);

@Resolver(of => User)
export class UserResolver {
  @InjectRepository(UserRepository)
  private readonly userRepository: UserRepository;

  @InjectRepository(UserMetaRepository)
  private readonly userMetaRepository: UserMetaRepository;

  @InjectRepository(UserEmail)
  private readonly userEmailRepository: Repository;

  @Authorized()
  @Query(returns => User)
  public User(
    @Arg('id', type => ID) id: string //
  ) {
    return this.userRepository.findOneOrFail(id);
  }

  @Authorized()
  @Query(returns => User)
  public async getUser(@Ctx() context: Context) {

  constructor(@InjectRepository(Post) public readonly postRepository: Repository) {
    super(Post, postRepository);
  }

  constructor(@InjectRepository(User) public readonly userRepository: Repository) {
    super(User, userRepository);
  }

Resolver,
  UseMiddleware,
} from "type-graphql";
import { FindOneOptions, LessThan, Repository } from "typeorm";
import { InjectRepository } from "typeorm-typedi-extensions";
import { Comment } from "../../entity/Comment";
import { QuestionCommentNotification } from "../../entity/QuestionCommentNotification";
import { MyContext } from "../../types/Context";
import { isAuthenticated } from "../shared/middleware/isAuthenticated";
import { OkResponse } from "../shared/OkResponse";
import { NotificationsResponse } from "./response";

const NOTIF_LIMIT = 50;
@Resolver(Comment)
export class CommentResolver {
  @InjectRepository(QuestionCommentNotification)
  private readonly questionCommentNotificationRepo: Repository<
    QuestionCommentNotification
  >;

  @Query(() => NotificationsResponse)
  @UseMiddleware(isAuthenticated)
  async notifications(
    @Ctx() { req }: MyContext,
    @Arg("cursor", { nullable: true }) cursor?: string
  ): Promise {
    const where: FindOneOptions["where"] = {
      userToNotifyId: req.session && req.session.userId,
    };

    if (cursor) {
      where.createdAt = LessThan(cursor);

constructor(
    @InjectRepository(FeatureFlagSegment)
    protected readonly repository: Repository,
    @Inject('EnvironmentService') readonly environmentService: EnvironmentService,
    @Inject('FeatureFlagService') readonly featureFlagService: FeatureFlagService,
    @Inject('ProjectService') readonly projectService: ProjectService,
    @Inject('SegmentService') readonly segmentService: SegmentService
  ) {
    super(FeatureFlagSegment, repository);
  }

  constructor(@InjectRepository(Author) public readonly authorRepository: Repository) {
    super(Author, authorRepository);
  }