Resolviendo las relaciones uno a uno

Para Evitar repetir codigo en los schemas se puede importar los schemas del user y agregarlos al validador del customer

const joi = require(‘joi’);

const { createUserSchema, updateUserSchema } = require('./user.schema');

const createCustomerSchema = joi.object({
  firstName: firstName.required(),
  lastName: lastName.required(),
  phone: phone.required(),
  user: createUserSchema
});

const updateCustomerSchema = joi.object({
  firstname: firstName,
  lastname: lastName,
  phone: phone,
  user: updateUserSchema
});

de esta forma si en un futuro se agrega un validador al user schema no habia que hacer nada en el customer schema

Sequelize está simplificando el código bastante!

Como puede ser una forma de tener las dos cosas? Me refiero a que el ultimo cambio del video nos quito la posibilidad de poder crear un Customer con ya un usuario creado.

Para modificar una columna se usa el método changeColumn en el boilerplate de la migración, seguido del nombre de la tabla y de la columna que se desea modificar y poniendo los atributos que definirán la nueva columna.

'use strict';
const { DataTypes } = require('sequelize');

const { CUSTOMER_TABLE } = require('../models/customer.model');

module.exports = {
  up: async (queryInterface) => {
    await queryInterface.changeColumn(CUSTOMER_TABLE, 'user_id', {
      field: 'user_id',
      allowNull: false,
      type: DataTypes.INTEGER,
      unique: true,
    });
  },

  down: async (queryInterface) => {
    // await queryInterface.dropTable(CUSTOMER_TABLE);
  },
};

Con esos cambios se vuelve a correr la migración, nota que en caso de que existan campos repetidos, no se permitirá correr la migración porque rompe con la nueva regla del campo unique. Manualmente se debe ir a la BD y arreglar esos índices.

Hecho esto se corre la migración.

Cuando se hace el request para obtener los customers, se hace el llamado a la asociación en el método find de customers.service.js. Ahí se incluye el alias de la asociación asignada en el modelo de customer:

async find() {
    const rta = await models.Customer.findAll({
      include: ['user']
    });
    return rta;
  }

De esa manera se resuelve la relación de forma anidada, de la misma manera se puede resolver a customers por el lado de users.

Para ello se hacen las respectivas asociaciones en user.model.js, nota que cuando se hace hasOne significa que la relación está de lado de customers:

class User extends Model {
  static associate(models) {
    this.hasOne(models.Customer, {
      as: 'customer',
      foreignKey: 'userId'
    })
  }
}

La asociación también debe colocarse en db/models/index.js:

const { User, UserSchema } = require('./user.model');
const { Customer, CustomerSchema } = require('./customer.model');

function setupModels(sequelize) {
  User.init(UserSchema, User.config(sequelize));
  Customer.init(CustomerSchema, Customer.config(sequelize));

  User.associate(sequelize.models);
  Customer.associate(sequelize.models);
}

module.exports = setupModels;

Para crear un user cuando se crea un customer, se debe modificar el método create dentro del modelo customer.service.js de la siguiente manera:

async create(data) {
    const newCustomer = await models.Customer.create(data, {
      include: ['user'],
    });
    return newCustomer;
  }

Debido a que ya se hizo una asociación de user-customer, se debe agregar el include con el nombre del la asociación hacia user.

Importante!! Observación sobre como correr migraciones que modifican restricciones/constraints en bases de datos

Ya quedaron las relaciones!

Estamos ahorrando código de forma bestial.