typeorm#createConnection TypeScript Examples

private static async connection(name: string = 'default') {
    const manager = getConnectionManager();

    let dbConnection;

    if (manager.has(name)) {
      dbConnection = await manager.get(name);
    } else {
      dbConnection = await createConnection(name);
    }

    if (!dbConnection.isConnected) {
      await dbConnection.connect();
    }

    return dbConnection;
  }

resetDBBeforeTest = async (): Promise<void> => {
  // This overwrites the DB_NAME used in the SharedModule's TypeORM init.
  // All the tests will run against the e2e db due to this overwrite.
  process.env.DB_NAME = TEST_DB_NAME;

  console.log(`Dropping ${TEST_DB_NAME} database and recreating it`);
  const connection = await createConnection({
    name: TEST_DB_CONNECTION_NAME,
    type: 'mysql',
    host: 'localhost',
    port: 3306,
    username: 'root',
    password: 'example',
  });

  await connection.query(`drop database if exists ${TEST_DB_NAME}`);
  await connection.query(`create database ${TEST_DB_NAME}`);

  await connection.close();
}

async function connectToDatabase() {
  try {
    await createConnection({
      name: "lr",
      type: "mariadb",
      host: "localhost",
      port: 3306,
      username: "root",
      password: "",
      database: "lr",
      synchronize: true,
      logging: false,
      entities: [Account, AccountValidation],
    });
    alt.log("Database connection successfull");
  } catch (err) {
    alt.log(err);
    setTimeout(() => connectToDatabase(), 5000);
  }
}

/**
     * Creates a connection to the iMessage database
     */
    async initialize() {
        this.db = await createConnection({
            name: "iMessage",
            type: "better-sqlite3",
            database: `${process.env.HOME}/Library/Messages/chat.db`,
            entities: [Chat, Handle, Message, Attachment]
        });

        return this.db;
    }

connectDatabase = async () => {
    const connectionOptions: ConnectionOptions = {
        type: "sqlite",
        database: resolve(process.cwd(), 'db.sqlite3'),
        entityPrefix: 'crw_',
        synchronize: true,
        entities: [
            ...ORMEntities,
        ]
    }

    await createConnection(connectionOptions);
}

createConnection()
  .then(_connection => {
    const app = express();

    app.set('view engine', 'ejs');
    app.use(bodyParser.urlencoded({ extended: false }));
    app.use(express.static('dist'));

    app.use('/user', userRoute.router);

    app.use('/admin', adminData.router);

    app.use(homeRouter);

    app.use(errorRoute.error404);

    app.listen(8080), console.log('Listening at 8080');
  })
  .catch(error => console.log(error));

/**
 * 데이터베이스 커넥션을 생성한다.
 */
export async function createDatabaseConnection(): Promise<void> {
  try {
    const connectionOpts: ConnectionOptions = {
      type: "mysql",
      host: env.database.host,
      port: env.database.port,
      username: env.database.usename,
      password: env.database.password,
      database: env.database.name,
      synchronize: env.database.synchronize,
      logging: env.database.logging,
      entities: [__dirname + "/entities/*{.ts,.js}"],
    };

    useContainer(Container);
    await createConnection(connectionOpts);
  } catch (error) {
    throw error;
  }
}

connect = async (config:MigrationDbConfig, db?: Promise<Connection>) => {
  const connectionPromise = db || (() => {
    let options = _.merge(Version1EntityDefaults, config.Database);
    return createConnection(options)

  })()

  return await connectionPromise;
}

run = async () => {
  await createConnection()
  const app = express()
  app.use('/public', express.static('public'))
  const admin = new AdminJS({
    resources: [
      createPhotoResource(),
      createUserResource(),
      createCustomResource(),
      createPostResource(),
      createMultiResource(),
    ],
    version: { admin: true },
    locale: {
      language: 'en',
      translations: {
        labels: {
          Photo: 'photos (Local)',
          User: 'users (AWS)',
          Custom: 'custom provider',
          Post: 'posts (GCP)',
        },
      },
    },
  })

  admin.watch()

  const router = buildRouter(admin)

  app.use(admin.options.rootPath, router)

  app.listen(PORT, () => {
    // eslint-disable-next-line no-console
    console.log(`Example app listening at http://localhost:${PORT}`)
  })
}

async function run() {
  const connection = await createConnection();
  const alertRepository = connection.getRepository(Alert);

  const alerts = await alertRepository.find();
  console.info(`Processing ${alerts.length} alerts.`);

  await Promise.all(
    alerts.map(async (alert) => processAlert(alert, alertRepository)),
  );
}

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,
  });
}

// Start a daily update for each sites.
exports.dailyUpdate = functions
  .runWith({ timeoutSeconds: 540 })
  .https.onRequest(async (req, res) => {
    const dbUrl = functions.config().database.url;
    process.env.SOFAR_API_TOKEN = functions.config().sofar_api.token;
    // eslint-disable-next-line no-undef
    const entities = dbEntities.map(extractEntityDefinition);
    const conn = await createConnection({
      ...dbConfig,
      url: dbUrl,
      entities,
    });
    try {
      await runDailyUpdate(conn);
      res.json({ result: `Daily update on ${new Date()}` });
    } catch (err) {
      await sendErrorToSlack('dailyUpdate', err);
      throw err;
    } finally {
      conn.close();
    }
  });

beforeAll(async () => {
  connection = await createConnection({
    type: 'postgres',
    host: process.env.HOST,
    port: 5432,
    username: process.env.USERNAME,
    password: process.env.PASSWORD,
    database: process.env.DB,
    schema: 'public',
    entities: [path.join(__dirname, '../', '**/*.entity{.ts,.js}')],
    migrationsRun: false,
    logging: true,
    logger: 'advanced-console',
    maxQueryExecutionTime: 1000,
    synchronize: false,
  });
});

createConn = () =>
  createConnection({
    type: "postgres",
    database: __prod__ ? undefined : "vsinder",
    url: __prod__ ? process.env.DATABASE_URL : undefined,
    entities: [join(__dirname, "./entities/*")],
    migrations: [join(__dirname, "./migrations/*")],
    // synchronize: !__prod__,
    logging: !__prod__,
  })

(async function() {
  const connection = await createConnection();

  console.log(
    await UserEntity.update(
      {
        email: args.email,
      },
      {
        isAdmin: true,
      },
    ),
  );

  await connection.close();
})();

createConnection(options)
  .then(async (connection) => {
    const app = express();
    app.use(express.json({limit: '4mb'}));
    app.use(express.urlencoded({limit: '4mb'}));
    app.use(cors());
    app.use(helmet());
    app.use(morgan("short"));
    app.use(express.json());

    app.use("/", routes);

    if (app.get("env") === "production") {
      app.use(function (req, res, next) {
        const protocol = req.get("x-forwarded-proto");
        protocol == "https" ? next() : res.redirect("https://" + req.hostname + req.url);
      });
    }

    await createOrIncrementClock(false);

    const port = config.get("server.port");

    app.get("/", function (req, res) {
      res.send("Backend SDK is running");
    });

     const carekit_key = fs.readFileSync(__dirname + '/carekit-sdk.key');
     const carekit_crt = fs.readFileSync(__dirname + '/carekit-sdk.crt');
    
     https.createServer({
      key: carekit_key, cert: carekit_crt,}, app)
      .listen(port, function () {
        console.log('CareKit Backend SDK is running!');
      });
    })
     .catch((error) => console.log(error));

connectDb = async (logging?: boolean) => {
  const connection = createConnection({
    type: 'postgres',
    host: process.env.DB_HOST,
    port: parseInt(process.env.DB_PORT ?? ''),
    username: process.env.DB_USERNAME,
    password: process.env.DB_PASSWORD,
    database: process.env.DB_NAME,
    entities: [
      Domain,
      Service,
      Vulnerability,
      Scan,
      Organization,
      User,
      Role,
      ScanTask,
      Webpage,
      ApiKey,
      SavedSearch,
      OrganizationTag
    ],
    synchronize: false,
    name: 'default',
    dropSchema: false,
    logging: logging ?? false,
    cache: true
  });
  return connection;
}

/// Returns the connection(pool) that should be used for all the jobs. The returned connection is always active, i.e. connected.
async function getActiveJobConnection() {
    const release = await activeConnectionMutex.acquire(); //restrict access to this function to only one concurrent caller (to prevent creating two default connections, which occurs primarily if two jobs are scheduled at just the same time)

    if (!jobConnection) {
        logger.info("Create new connection to database...");
        jobConnection = await createConnection();
    } else if (!jobConnection.isConnected) {
        logger.info("Job database connection is no longer connected. Reconnect...");
        //Do this always, to have no transaction log that uses a connection that was closed (which then would result in errors)
        invalidateActiveTransactionLog(); // that might not be necessary here, but include it for safety reasons
        await jobConnection.connect();
    }

    release();

    return jobConnection;
}

public static getConnection = async (url: string): Promise<Connection> => {
    const connection = await createConnection({
      // Typeorm does not allow two connections to have the same name
      // So we use a different name everytime in order to have parallel connections
      name: `${Date.now()}`,
      type: 'mongodb',
      useNewUrlParser: true,
      useUnifiedTopology: true,
      url,
      entities: [Vault, VaultIndex, Document, Capability, Revocation, Chunk],
    });
    return connection;
  };

createConnection()
  .then(async () => {
    // create express app
    const app = express();
    // Middlewares
    app.use(cors());
    app.use(helmet());

    app.use(express.json());
    // Routes
    app.use('/', routes);

    // start express server
    app.listen(PORT, () => console.log(`Server running on port ${PORT}`));
  })
  .catch(error => console.log(error));

async function main() {
  await createConnection();
  const schema = await buildFederatedSchema({ resolvers: [RequestResolver] });
  const context = ({ req }: Context) => {
    return { tenantId: req.headers[TENANT_HEADER] || '' };
  };
  const server = new ApolloServer({ schema, context });
  server.applyMiddleware({ app });
  app.listen({ port: APP_PORT });
}

async connect() {
    this.connection = await createConnection({
      type: 'postgres',
      host: config.db.host,
      port: config.db.port,
      database: config.db.name,
      username: config.db.user,
      password: config.db.password,
      entities: [TransferBalance],
      synchronize: true,
    });
    this.repo = getRepository(TransferBalance);
    log.info('Connected to database');
  }

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;
  }

jest.mock('typeorm', () => ({
  Entity: jest.fn(),
  PrimaryGeneratedColumn: jest.fn(),
  Column: jest.fn(),
  createConnection: jest.fn(),
  getConnection: jest.fn(),
  getConnectionManager: jest.fn(),
  getRepository: jest.fn()
}))

export function connect(logging: boolean = false) {
  return createConnection({
    type: "sqlite",
    database: ":memory:",
    entities: [path.resolve(__dirname, "entities", "*.{js,ts}")],
    synchronize: true,
    logging,
  });
}

typeormLoader: MicroframeworkLoader = async (settings: MicroframeworkSettings | undefined) => {

    const loadedConnectionOptions = await getConnectionOptions();

    const connectionOptions = Object.assign(loadedConnectionOptions, {
        type: env.db.type as any, // See createConnection options for valid types
        host: env.db.host,
        port: env.db.port,
        username: env.db.username,
        password: env.db.password,
        database: env.db.database,
        synchronize: env.db.synchronize,
        logging: true,
        logger: 'advanced-console',
        entities: env.app.dirs.entities,
        migrations: env.app.dirs.migrations,
    });

    const connection = await createConnection(connectionOptions);

    await connection.runMigrations();

    if (settings) {
        settings.setData('connection', connection);
        settings.onShutdown(() => connection.close());
    }
}

async function configureORM() {
  class User {
    id!: number
    name!: string
    projects!: Project[]
  }

  class Project {
    id!: number
    name!: string
    user!: User
  }

  const UserSchema = new EntitySchema<User>({
    name: 'User',
    target: User,
    columns: {
      id: { primary: true, type: 'int', generated: true },
      name: { type: 'varchar' },
    },
    relations: {
      projects: {
        target: 'Project',
        type: 'one-to-many',
        inverseSide: 'user'
      }
    }
  })

  const ProjectSchema = new EntitySchema<Project>({
    name: 'Project',
    target: Project,
    columns: {
      id: { primary: true, type: 'int', generated: true },
      name: { type: 'varchar' },
    },
    relations: {
      user: { target: 'User', type: 'many-to-one' }
    }
  })

  const conn = await createConnection({
    type: 'sqlite',
    database: ':memory:',
    entities: [UserSchema, ProjectSchema]
  })

  return { User, Project, conn }
}

async run(): Promise<void> {
        dotenv.config()

        let cfg: ConnectionOptions = {
            ...createOrmConfig(),
            subscribers: [],
            synchronize: false,
            migrationsRun: false,
            dropSchema: false,
            logging: ["query", "error", "schema"],
        }

        let connection = await createConnection(cfg)
        try {
            await connection.runMigrations({transaction: 'all'})
        } finally {
            await connection.close().catch(err => null)
        }
    }