TypeScript typeorm createConnection Examples

Example #1

File: db.ts Project: coderfox/Another-SS-Panel

export default () =>
  createConnection({
    type: "sqlite",
    database: dbPath,
    entities: [__dirname + "/../models/*.js"],
    synchronize: true,
  }).then(conn => {
    connection = conn;
  });

Example #2

File: conn.ts Project: empirefox/tompeg4

export function connect(driver: DriverOptions): Promise<Connection> {
  return createConnection({
    driver: Object.assign(driver),
    entities: [
      Phone,
    ],
    autoSchemaSync: false,
  });
}

Example #3

File: main.ts Project: A-Horse/bblist-backend

function main() {
  createConnection(getPostgresConfig())
    .then(() => {
      console.log('database connection successful.');

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

Example #4

File: database.provider.ts Project: jonathan-patalano/blog-api

 useFactory: async (configService: ConfigService) =>
   await createConnection({
     type: "postgres",
     host: configService.getString("DB_HOST"),
     port: configService.getNumber("DB_PORT"),
     username: configService.getString("DB_USER"),
     password: configService.getString("DB_PWD"),
     database: configService.getString("DB_NAME"),
     entities: [__dirname + "/../../**/*.entity{.ts,.js}"],
     synchronize: true
   }),

Example #5

File: database.provider.ts Project: fanybook/Nestjs30Days

 useFactory: async () => await createConnection({
     type: 'mssql',
     host: 'localhost',
     port: 1433,
     username: '******',
     password: '******',
     database: 'IronManNest',
     entities: [
         __dirname + '/Users/*.entity{.ts,.js}'
     ]
 })

Example #6

File: database.providers.ts Project: odykyi/nestjs-starter

 useFactory: async () => await createConnection({
   type: 'mysql',
   host: 'localhost',
   port: 3306,
   username: '******',
   password: '******',
   database: 'test',
   entities: [
     __dirname + '/../**/**.entity.ts',
   ],
   autoSchemaSync: true,
 }),

Example #7

File: index.ts Project: loki2302/html5-experiment

 return async () => {
     if(connection == null) {
         connection = await createConnection({
             type: 'sqlite',
             database: 'my.db',
             entities: [
                 Todo
             ],
             synchronize: true
         });
     }
     return connection;
 }

Example #8

File: save.ts Project: uldissturms/playgrounds

const newConnection = async () => {
  const con = await createConnection({
    host: 'localhost',
    type: 'mysql',
    username: '******',
    password: '******',
    database: 'typeorm_test',
    entities,
    synchronize: true,
    logging: ['error', 'query'],
  })

  return con
}

Example #9

File: main.ts Project: joffray589/typeorm-sample

(async () => {
    try{
        let connection = await createConnection(dbOptions);

        console.log("connection.isConnected = " + connection.isConnected);

        await connection.getRepository(FooEntity).find(); // this will throw ECONNREFUSED

        console.log("Mysql connection ok");
    }
    catch(e){
        console.error("Mysql connection error : " + e );
    }
})();

Example #10

File: TypeOrmModule.ts Project: pleerock/microframework-typeorm

    private createConnections() {
        let promises: Promise<any>[] = [];

        if (this.configuration.connection)
            promises.push(createConnection(this.normalizeConnectionOptions(this.configuration.connection)));

        if (this.configuration.connections)
                this.configuration
                    .connections
                    .map(connectionOptions => createConnection(this.normalizeConnectionOptions(connectionOptions)))
                    .forEach(closePromise => promises.push(closePromise));

        return Promise.all(promises);
    }