typeorm "CREATE DATABASE" migration - mysql

Question

I need to create database before connection and work with db. I'm using nest.js typeorm, provided all configurations. When I start my application it says
"Unable to connect to the database. Error: ER_BAD_DB_ERROR: Unknown database 'test'".
Once again: there is not DB "Test" in my MySQL Workbench => when I start the application
I want the application to create the database itself (not by me manually)
Is it possible?

Answer 1

I found a way to achieve this for postgresql. Also I'm using Nest.js and Typeorm too. Firstly, I created two sql files (one for check if database exists and one for create db) and then a config file for database. These files contents are like below.
checkDbIfExists.sql
SELECT 1 FROM pg_database WHERE datname = 'test'
createDB.sql
CREATE DATABASE test
config.ts
import { DynamicModule } from '#nestjs/common';
import { TypeOrmModule, TypeOrmModuleOptions } from '#nestjs/typeorm';
import { createConnection, getManager } from 'typeorm';
import { PostgresConnectionOptions } from 'typeorm/driver/postgres/PostgresConnectionOptions';
import * as path from 'path';
const fs = require('fs');
const checkDBScript: string = fs
.readFileSync(path.join(__dirname, '../script/checkDBIfExists.sql'))
.toString();
const createDb: string = fs.readFileSync(path.join(__dirname, '../script/createDB.sql')).toString();
const CreateDBIfNotExists = async (options: TypeOrmModuleOptions): Promise<void> => {
const connection = await createConnection(options as PostgresConnectionOptions);
const manager = getManager();
const result = await manager.query(checkDBScript);
if (result.length === 0) await manager.query(createDb);
connection.close();
};
const DBConfig = async (): Promise<DynamicModule> => {
let options: TypeOrmModuleOptions = {
type: 'postgres',
host: 'localhost',
port: 5432,
username: 'postgres',
password: 'asd',
entities: [],
synchronize: true,
cli: {
migrationsDir: 'persistence/migrations'
}
};
await CreateDBIfNotExists(options);
options = { ...options, database: 'test' };
return TypeOrmModule.forRoot(options);
};
export default DBConfig;
Then I added these lines
nest-cli.json
"compilerOptions": {
"assets": ["persistence/script/*"]
}
app.module.ts
#Module({
imports: [DBConfig()]
...

Answer 2

NestJS can't create the database, you need to manually create it before starting your application.
If you want it to be automatic, you can use a docker service to create your database when starting your docker compose with docker-compose up
version: "3.6"
services:
db:
image: mysql:8.0.20
command: --default-authentication-plugin=mysql_native_password
restart: always
ports:
- 3306:3306
environment:
- MYSQL_DATABASE=<database-name>
- MYSQL_ROOT_PASSWORD=<password>

Answer 3

I am using TypeORM version 0.3.11, so while M. Erim Tuzcuoglu's solution works for now, it's using deprecated methods.
Here is my function that is based on the newer DataSource approach.
export const createDBIfNotExists = async (): Promise<void> => {
const dbOptions = dbConfig().db;
const { createDatabase, database } = dbOptions;
if (!createDatabase) {
return;
}
const dataSource = new DataSource({
type: 'postgres',
...dbOptions,
database: 'postgres',
});
await dataSource.initialize();
const result = await dataSource.query(
`SELECT 1 FROM pg_database WHERE datname = '${database}'`
);
if (!result.length) {
console.log(`Creating database with name "${database}"`);
await dataSource.query(`CREATE DATABASE "${database}"`);
}
await dataSource.destroy();
}
Specifying postgres as the database for the connection is a bit "hacky" because it assumes it's existence. However in my case that is acceptable. Without it it would fail to connect.
I should also mention that dbConfig function is very similar to the approach provided in Nest documentation:
// Use process.env for the values, I've hardcoded them just for clarity here
export const dbConfig = (): { db: IDBConfig } => ({
db: {
host: 'localhost',
port: 5432,
database: 'your-db-name',
username: 'username',
password: 'password',
migrationsRun: true,
createDatabase: true,
logging: true,
synchronize: false,
},
});
Then in my main.ts I just call the function:
async function bootstrap() {
await createDBIfNotExists();
// ...
}
This allows me to simply change POSTGRES_DB env variable and it would create and use this DB automatically when I start the app (while also checking for the RUN_MIGRATION env).
It's quite specific to the requirements I had, but I hope the general implementation example could help someone in the future.