typeorm#Connection TypeScript Examples

static async resetEntities(seedData: boolean = false) {

    return new Promise(async (resolve) => {
      const connection: Connection = await this.seedConnection();

      await connection.synchronize(true).then(async () => {

        return connection.close().then(async () => {

          if (seedData) {
            await this.seedDb();
            resolve(true);
          } else {
            resolve(true);
          }
        });

      });

    });
  }

async initialize(): Promise<Connection> {
        const isDev = process.env.NODE_ENV !== "production";

        // If the DB is set, but not connected, try to connect
        if (this.db) {
            if (!this.db.isConnected) await this.db.connect();
            return this.db;
        }

        let dbPath = `${app.getPath("userData")}/config.db`;
        if (isDev) {
            dbPath = `${app.getPath("userData")}/bluebubbles-server/config.db`;
        }

        this.db = await createConnection({
            name: "config",
            type: "better-sqlite3",
            database: dbPath,
            entities: [Config, Alert, Device, Queue, Webhook, Contact, ContactAddress],
            // We should really use migrations for this.
            // This is me being lazy. Maybe someday...
            synchronize: true
        });

        // Load default config items
        await this.loadConfig();
        await this.setupDefaults();
        return this.db;
    }

/**
     * Checks that the the given jti is unique by logging in the database, and checking for earlier entries in the log. Could be improved for more demanding performance needs by adding indexes for further claims.
     * @param jti 
     * @param iss 
     * @param sub 
     */
    constructor(@inject("Promise<Connection>") private connection:Promise<Connection>) {

    }

constructor(
    private readonly appService: AppService,
    private readonly appServiceV2: PurseSavingService,
    /**
     * This is deprecated in typeorm for now,
     * but the DataSource object still not injectable in Nest.js,
     * because of that we should use deprecated [Connection] until [DataSource]
     * will be injectable
     */
    private readonly connection: Connection,
  ) {
  }

public async run(factory: Factory, connection: Connection): Promise<void> {
    console.log('quizSampleData', quizSampleData);
    await getManager().query('SET foreign_key_checks = 0');
    await getManager().query('TRUNCATE quizes');
    await getManager().query('TRUNCATE questions');
    await getManager().query('TRUNCATE options');
    await getManager().query('SET foreign_key_checks = 1');

    for (let i = 0; i < quizSampleData.length; i++) {
      const { quizTitle, quizDescription, questions } = quizSampleData[i];

      const quiz = new Quiz();
      quiz.title = quizTitle;
      quiz.description = quizDescription;
      await quiz.save();

      for (let j = 0; j < questions.length; j++) {
        const { question, options } = questions[j];

        const que = new Question();
        que.question = question;
        que.quiz = quiz;
        await que.save();

        for (let k = 0; k < options.length; k++) {
          const { isCorrect, text } = options[k];
          const opt = new Option();
          opt.isCorrect = isCorrect;
          opt.text = text;
          opt.question = que;
          await opt.save();
        }
      }
    }
  }

async function getConnection(): Promise<Connection> {
  const connManager = getConnectionManager();
  if (connManager.has("default")) {
    await connManager.get().close();
  }

  return await createConnection({
    type: "postgres",
    url: postgres_url,
    entities: [Confession],
    synchronize: true,
    logging: false,
  });
}

export async function runDailyUpdate(conn: Connection) {
  const today = moment()
    .utc()
    .hours(23)
    .minutes(59)
    .seconds(59)
    .milliseconds(999);

  const yesterday = moment(today);
  yesterday.day(today.day() - 1);
  console.log(`Daily Update for data ending on ${yesterday.date()}`);
  try {
    await getSitesDailyData(conn, yesterday.toDate());
    console.log('Completed daily update.');
  } catch (error) {
    console.error(error);
  }
}

public async run(factory: Factory, connection: Connection): Promise<any> {
    const admin = await UserEntity.createQueryBuilder('user')
      .where('user.email = :email', {email: EMAIL})
      .getOne();

    if (!admin) {
      await UserEntity.create({
        email: EMAIL,
        password: PASSWORD,
        isAdmin: true,
      }).save();
    }
  }

function executeJob(job: (manager: EntityManager) => Promise<void>, jobConnectionGetter: () => Promise<Connection>): () => Promise<void> {
    return async function() { //return a real function, not an arrow-function here, because we need this to be set according to the context defined as part of the CronJob creation
        //"this" is the context of the cron-job -> see definition of node cron package
        this.stop(); //start stop, so that the same job is never executed in parallel

        try {
            //Get the connection that should be used to execute the job in
            //we assume that the returned connection is always active
            const connection = await jobConnectionGetter();

            //The entity manager that should be used to manage the entities
            const manager = connection.manager;

            //execute the job with the manager
            await job(manager);
        } catch (e) {
            logger.error(`Can't execute job: ${job.name} due to error with message: ${e.message}`);
            logger.debug(e);
        }

        this.start();
    };
}

constructor(connection: Connection, allowDataBaseDestruction: boolean) {
    this.connection = connection;
    this.allowDataBaseDestruction = allowDataBaseDestruction;
    this.vaults = connection.getMongoRepository(Vault);
    this.vaultIndexes = connection.getMongoRepository(VaultIndex);
    this.documents = connection.getMongoRepository(Document);
    this.capabilities = connection.getMongoRepository(Capability);
    this.revocations = connection.getMongoRepository(Revocation);
    this.chunks = connection.getMongoRepository(Chunk);
  }

/**
	 * Creates and returns Typeorm connection based on selected configuration file.
	 *
	 * @async
	 * @private
	 * @param {string} configPath A path to Typeorm config file.
	 * @param {Flags} flags An object with command flags.
	 * @returns {Connection} A connection instance.
	 */
	private async getConnection( configPath: string, flags: Flags ): Promise<Connection> {
		let root = process.cwd();
		let configName = configPath;

		if ( isAbsolute( configName ) ) {
			root = dirname( configName );
			configName = basename( configName );
		}

		const cwd = dirname( resolve( root, configName ) );
		process.chdir( cwd );

		const connectionOptionsReader = new ConnectionOptionsReader( { root, configName } );
		const connectionOptions = await connectionOptionsReader.get( flags.connection || 'default' );
		return getConnectionManager().create( connectionOptions );
	}

export async function getConnection(): Promise<Connection> {
  if (connection) {
    return connection
  }

  connection = await createConnection()

  return connection
}

public async getConnection(): Promise<Connection> {
    if (DatabaseService.connection instanceof Connection) {
      return DatabaseService.connection;
    }
    // const options = await getConnectionOptions(`orm_${new Date().getTime()}`);

    try {
      DatabaseService.connection = await createConnection();
      this.logger.log('INFO', `Connection established`);
    } catch (e) {
      this.logger.log('ERROR', 'Cannot establish database connection');
      process.exit(1);
    }

    return DatabaseService.connection;
  }

/*
    NOTE: It need to use different services,
    that's why this subscriber is connected by the constructor.
   */
  constructor(
    @InjectConnection() readonly connection: Connection,
    private readonly _messageService: MessageService,
    private readonly _messageKeyService: MessageKeyService,
    private readonly _userService: UserService,
    private readonly _userAuthService: UserAuthService,
    private readonly _languageService: LanguageService,
    private readonly _transactionService: TransactionService,
    private readonly _billService: BillService,
  ) {
    connection.subscribers.push(this);
  }

persistenceProviders: Provider[] = [
  {
    provide : MediaDITokens.MediaFileStorage,
    useClass: MinioMediaFileStorageAdapter,
  },
  {
    provide   : MediaDITokens.MediaRepository,
    useFactory: connection => connection.getCustomRepository(TypeOrmMediaRepositoryAdapter),
    inject    : [Connection]
  }
]

constructor(dbConnection: Connection | null, redisClient: Redis | null) {
    if (dbConnection) {
      this.container.set(DB_TYPE.ORM, dbConnection)
    }

    if (redisClient) {
      this.container.set(DB_TYPE.REDIS, redisClient)
    }
  }

constructor(
    connection: Connection,
    notifService: NotificationService,
    queueSSEService: QueueSSEService,
  ) {
    this.notifService = notifService;
    this.queueSSEService = queueSSEService;
    connection.subscribers.push(this);
  }

constructor(relation: RelationMetadata, connection: Connection) {
    super(
      directLoader(
        relation,
        connection,
        relation.inverseEntityMetadata.primaryColumns[0].propertyName
      )
    );
  }

public async seed(factory: Factory, connection: Connection): Promise<OrderStatus> {
        const em = connection.createEntityManager();
        const statusData: any = [
            {
            orderStatusId: 1,
            name: 'In Progress',
            isActive: 1,
            },
            {
                orderStatusId: 2,
                name: 'Shipped',
                isActive: 1,
            },
            {
                orderStatusId: 3,
                name: 'Delivered',
                isActive: 1,
            },
            {
                orderStatusId: 4,
                name: 'completed',
                isActive: 1,
            },
        ];
        let i = 0;
            for ( i; i < statusData.length; i++ ) {
                const orderStatus = new OrderStatus();
                    orderStatus.orderStatusId = statusData[i].orderStatusId;
                    orderStatus.name = statusData[i].name;
                    orderStatus.isActive = statusData[i].isActive;
                    await em.save(orderStatus);
                }
        return statusData;
    }

/**
   * Run migrations in the "migrations" folder;
   */
  static async migrate(): Promise<void> {
    let connection: Connection | undefined
    try {
      connection = await createDBConnection()
      if (connection) await connection.runMigrations()
    } finally {
      if (connection) await connection.close()
    }
  }

DBConnect = async () => {
  let connection: Connection | undefined;
  try {
    connection = getConnection();
  } catch (e) {
  }

  try {
    if (connection) {
      if (!connection.isConnected) {
        await connection.connect();
      }
    } else {
      await createConnection(ORMConfig);
    }
    console.log("? Database connection was successful!");
  } catch (e) {
    console.error('ERROR: Database connection failed!!', e);
    throw e;
  }
}

db: Connection = null;

constructor(type: ObjectType<T>, connection: Connection) {
    this.type = type;
  }

private connection: Connection;

connection: Connection

database: Connection

db: Connection

async function RegisterDependencies(configFn:() => Promise<AdrConnectivityConfig>, db?: Promise<Connection>): Promise<void> {
    let config = await configFn();

    const level = process.env.LOG_LEVEL || "warn";

    const transports:Transport[] = [
        new winston.transports.Console({
            handleExceptions: true,
            level
        }),
    ];
    if (process.env.LOG_FILE) {
        transports.push(new winston.transports.File({ filename: process.env.LOG_FILE, level }))
    }

    const logger = winston.createLogger({
        transports,
        exitOnError: false,
        format: winston.format.combine(
            winston.format.timestamp(),
            winston.format.json({
                replacer: combineReplacers(errorReplacer,configReplacer,axiosReplacer)
            })
        )
    });


    let connection = db || (() => {
        let options = _.merge(EntityDefaults, config.Database);
        return createConnection(options)

    })()

    container.register<Promise<Connection>>(
        "Promise<Connection>",
        {
            useValue: connection
        });

    container.register("Logger", { useValue: logger })

    if (process.env.ADR_BACKEND_EXPOSE_ECOSYSTEM_ERRORS === "true") {
        container.register("EcosystemErrorFilter", { useValue: GenerousEcosystemErrorFilter })
    } else {
        container.register("EcosystemErrorFilter", { useValue: SecretiveEcosystemErrorFilter })
    }

    container.register("DataHolderMetadataProvider", { useClass: SelfHealingDataHolderMetadataProvider })

    // TODO replace the DevClientCertificate injector headers with actual certificate made with node-forge
    if (config.mtls?.ca) {
        container.register("ClientCertificateInjector", {
            useValue: new DefaultClientCertificateInjector(
                config.mtls
            )
        })
    } else {
        container.register("ClientCertificateInjector", { useClass: DevClientCertificateInjector })
    }

    container.register("AdrConnectivityConfig", { useValue: configFn })
    container.register("AdrGatewayConfig", { useValue: configFn }) // TODO cleanup so there is only one config
    container.register("Cache", { useValue: new DefaultCache() })

}

async function augmentSites(connection: Connection) {
  const siteRepository = connection.getRepository(Site);
  const regionRepository = connection.getRepository(Region);
  const HistoricalMonthlyMeanRepository = connection.getRepository(
    HistoricalMonthlyMean,
  );
  const allSites = await siteRepository.find();

  const start = new Date();
  console.log(`Augmenting ${allSites.length} sites...`);
  await Bluebird.map(
    allSites,
    async (site) => {
      const augmentedData = await getAugmentedData(site, regionRepository);
      await siteRepository.update(site.id, augmentedData);
      // Add HistoricalMonthlyMeans
      const [longitude, latitude] = (site.polygon as Point).coordinates;
      const HistoricalMonthlyMeans = await getHistoricalMonthlyMeans(
        longitude,
        latitude,
      );
      await Promise.all(
        HistoricalMonthlyMeans.map(async ({ month, temperature }) => {
          try {
            await (temperature &&
              HistoricalMonthlyMeanRepository.insert({
                site,
                month,
                temperature,
              }));
          } catch {
            console.warn(
              `Monthly max values not imported for ${site.id} - the data was likely there already.`,
            );
          }
        }),
      );
    },
    { concurrency: 1 },
  );
  console.log(
    `Augmented ${allSites.length} sites in ${
      (new Date().valueOf() - start.valueOf()) / 1000
    } seconds`,
  );
}