Cambiar a Mysql demo (opcional)

Si tienen algún problema con la autenticación de root, pueden probar eliminando MYSQL_USER=root del environment.
La conexión quedaría así:

  mysql:
    image: mysql:5
    environment:
      - MYSQL_DATABASE=platzi_store
      - MYSQL_ROOT_PASSWORD=root
    ports:
      - '3306:3306'
    volumes:
      - ./mysql_data:/var/lib/mysql

Si tienes el puerto ocupado (y no por un contenedor):
$ sudo lsof -i -n -P|grep 3306

luego:
$ sudo kill nro_del_PDI

y lanza de nuevo :
$ docker-compose up -d phpmyadmin

Conexion con SQL Server

En las variables de entorno, habria que agregar:

SQLSERVER_DATABASE=my_db
SQLSERVER_USER=sa
SQLSERVER_SA_PASSWORD=1SuperPassword1
SQLSERVER_PORT=1433
SQLSERVER_HOST=localhost

Use la imagen del 2017, porque por alguna razon no me toma los volumes la 2019.

Agregar el servicio al docker-compose.yml

  sql-server:
    image: mcr.microsoft.com/mssql/server:2017-latest
    ports:
      - "1433:1433"
    environment:
      - ACCEPT_EULA=Y
      - SA_PASSWORD=SuperPassword(!)
      - MSSQL_PID=Express
    volumes:
      - ./sqlserver:/var/opt/mssql

Imagen: https://hub.docker.com/_/microsoft-mssql-server
Por alguna razon microsoft no agrego la variable de entorno para crear la base de datos por defecto. Por lo que entren con el IDE al motor y crean la base de datos my_db

Pueden ver todo el hilo aqui con el issue cerrado: https://github.com/Microsoft/mssql-docker/issues/2

Ejecutar docker-compose up -d sql-server para levantar el servidor.

Instalar el driver npm install --save mssql
Fuente: https://www.npmjs.com/package/mssql

En config.ts agregar la coleccion del sql-server:

...
    sqlserver: {
      dbName: process.env.SQLSERVER_DATABASE,
      port: parseInt(process.env.SQLSERVER_PORT),
      password: process.env.SQLSERVER_SA_PASSWORD,
      user: process.env.SQLSERVER_USER,
      host: process.env.SQLSERVER_HOST,
    },
...

En el database.module.ts se agrega el objeto de conexion

      useFactory: (configService: ConfigType<typeof config>) => {
        const { user, host, dbName, password, port } = configService.sqlserver;
        return {
          type: 'mssql',
          host,
          port,
          username: user,
          password,
          database: dbName,
          synchronize: true,
          autoLoadEntities: true,
          options: {
            encrypt: false,
          },
        };
      },

Les dejo como configure los 2 motores en simultaneo:

Config:

import { registerAs } from '@nestjs/config';

export default registerAs('config', () => {
  return {
    postgres: {
      dbName: process.env.POSTGRES_DB,
      port: parseInt(process.env.POSTGRES_PORT, 10),
      user: process.env.POSTGRES_USER,
      password: process.env.POSTGRES_PASSWORD,
      host: process.env.POSTGRES_HOST,
    },
    mysql: {
      dbName: process.env.MYSQL_DB,
      user: process.env.MYSQL_USER,
      password: process.env.MYSQL_PASSWORD,
      port: parseInt(process.env.MYSQL_PORT),
      host: process.env.MYSQL_HOST,
    },
    apiKey: process.env.API_KEY,
    configuration: process.env.CONFIGURATION,
  };
});

Schema:

import * as Joi from 'joi';

export const pgSchema = Joi.object({
  API_KEY: Joi.number().required(),
  POSTGRES_DB: Joi.string().required(),
  POSTGRES_USER: Joi.string().required(),
  POSTGRES_PASSWORD: Joi.string().required(),
  POSTGRES_HOST: Joi.string().required(),
  POSTGRES_PORT: Joi.number().required(),
  PORT: Joi.number().required(),
});

export const mysqlSchema = Joi.object({
  MYSQL_DB: Joi.string().required(),
  MYSQL_USER: Joi.string().required(),
  MYSQL_PASSWORD: Joi.string().required(),
  MYSQL_HOST: Joi.string().required(),
  MYSQL_PORT: Joi.number().required(),
});

Database Module:

imports: [
    TypeOrmModule.forRootAsync({
      name: 'mysqlDB',
      useFactory: (configService: ConfigType<typeof config>) => {
        const { dbName, user, password, host, port } = configService.mysql;
        return {
          type: 'mysql',
          host,
          port,
          username: user,
          password,
          database: dbName,
          synchronize: true,
          autoLoadEntities: true,
        };
      },
      inject: [config.KEY],
    }),
    TypeOrmModule.forRootAsync({
      name: 'postgresDB',
      useFactory: (configService: ConfigType<typeof config>) => {
        const { dbName, user, password, host, port } = configService.postgres;
        return {
          type: 'postgres',
          host,
          port,
          username: user,
          password,
          database: dbName,
          synchronize: true,
          autoLoadEntities: true,
        };
      },
      inject: [config.KEY],
    }),
  ],

Products Module:

@Module({
  imports: [TypeOrmModule.forFeature([Product, Category, Brand], 'mysqlDB')],
  controllers: [ProductsController, CategoriesController, BrandsController],
  providers: [ProductsService, CategoriesService, BrandsService],
  exports: [ProductsService],
})

Product Service:

constructor(
    @InjectRepository(Product, 'mysqlDB')
    private productRepo: Repository<Product>,
  ) {}

Para quienes esten siguiendo el curso en este momento
La configuracion para mysql es la siguiente

  mysql:
    image: mysql:8
    environment:
     - MYSQL_DATABASE=my_db
     - MYSQL_ROOT_PASSWORD=123456
    ports:
      - '3306:3306'
    volumes:
      - ./mysql_data:/var/lib/mysql

Lo que vimos:

.env

MYSQL_DATABASE=my_db
MYSQL_USER=root
MYSQL_ROOT_PASSWORD=123456
MYSQL_PORT=3306
MYSQL_HOST=localhost

config.ts

mysql: {
      host: process.env.MYSQL_HOST,
      dbName: process.env.MYSQL_DATABASE,
      port: parseInt(process.env.MYSQL_PORT, 10),
      user: process.env.MYSQL_USER,
      password: process.env.MYSQL_ROOT_PASSWORD,
    },

database.module.ts

imports: [
    TypeOrmModule.forRootAsync({
      inject: [config.KEY],
      useFactory: (configService: ConfigType<typeof config>) => {
        const { user, password, host, dbName, port } = configService.mysql;

        return {
          type: 'mysql',
          host,
          port,
          username: user,
          password,
          database: dbName,
          synchronize: true,
          autoLoadEntities: true,
        };
      },
    }),
  ],

Con mariadb:

Si estan en una mac con m1 no olviden de especificar antes de la imagen de mysql la plataforma

mysql:
    platform: linux/x86_64
    image: mysql:5

Recuerden que synchronize es solo para DEV

import { Module, Global } from '@nestjs/common';
import { Client } from 'pg';
import { ConfigType } from '@nestjs/config';
import { TypeOrmModule } from '@nestjs/typeorm';
import config from '../config/config';

const API_KEY = 'ASdasdasd';
const API_KEY_PROD = 'PRODasdasdas';

@Global()
@Module({
  imports: [
    TypeOrmModule.forRootAsync({
      inject: [config.KEY],
      useFactory: (configService: ConfigType<typeof config>) => {
        const { user, host, dbName, password, port } = configService.mysql;

        return {
          type: 'mysql',
          host: host,
          port: port,
          username: user,
          password: password,
          database: dbName,
          synchronize: process.env.NODE_ENV === 'prod' ? false : true,
          autoLoadEntities: process.env.NODE_ENV === 'prod' ? false : true,
        };
      },
    }),
  ],
  providers: [
    {
      provide: 'API_KEY',
      useValue: process.env.NODE_ENV === 'prod' ? API_KEY_PROD : API_KEY,
    },
    {
      provide: 'PG',
      useFactory: (configService: ConfigType<typeof config>) => {
        const { user, host, dbName, password, port } = configService.postgres;
        const client = new Client({
          user,
          host,
          database: dbName,
          password,
          port,
        });
        client.connect();
        return client;
      },
      inject: [config.KEY],
    },
  ],
  exports: ['API_KEY', 'PG', TypeOrmModule],
})
export class DatabaseModule {}

Si tienen Windows y les devuelve el error:

ERROR: for mysql  Cannot start service mysql: Ports are not available: listen tcp 0.0.0.0:3306

Iniciar el Administrador de tareas, ir a la pestaña de Servicios y detener el servicio de MySQL80. Luego volver a correr el contenedor:

docker-compose up -d mysql
docker-compose up -d phpmyadmin

Por si alguien está haciendo el curso con un Mac con chip M1 para la fecha en la que pongo este comentario todavía no está adaptado el contenedor de MySql si intentáis correrlo como el profesor os dará un error para evitar este error solo tenéis que ponerlo como este:

mysql:
    image: mysql:5
    platform: linux/x86_64
    environment:
      - MYSQL_DATABASE=my_db
      - MYSQL_USER=root
      - MYSQL_ROOT_PASSWORD=123456
    ports:
      - '3306:3306'
    volumes:
      - ./data/mysql_data:/var/lib/mysql

Si alguien tiene un problema como el siguiente:

ERROR: no matching manifest for linux/arm64/v8 in the manifest list entries

Se puede solucionar agregrando lo siguiente en mysql:

platform: linux/amd64

😍 TypeORM

👏

En mi caso si funciono la parte con mysql
cuando usaba postgres me salia error con el password no se por que pero al menos mysql funciona

Que excelente explicación de Nico