Partial y Required Type

Partial & Required en TS

Estos dos tipos de datos nos sirven para declarar que todos los campos de una interfaz son opcionales u obligatorios.

interface Product {
    title: string;
    price: number;
    category: string;
    size?: string;
}

type UpdateProduct = Partial<Product>
type StrictProduct = Required<Product>

De esa forma en UpdateProduct, todos los valores de Product van a ser opcionales y a la inversa en el caso de StrictProduct

Les comparto mis apuntes. 😄

Partial

Nos permite colocar todos los parámetros de una interface como opcionales, sin necesidad que colocar ? parámetro por parámetro.

Sintaxis

interface InterfaceName extends Partial<Interface> {
		statements
}

type TypeName = Partial<TypeOrInterface>;

Required

Nos permite colocar todos los parámetros de una interface como obligatorios.

Sintaxis

interface InterfaceName extends Required<Interface> {
		statements
}

type TypeName = Required<TypeOrInterface>;

Reutilización de DTOs

Podemos reutilizar nuestro DTO normalmente, ya que son interfaces.

Ejemplo

import { Product } from "./product.model";

export interface CreateProductDto extends Omit<Product, 'id' | 'createdAt' | 'updatedAt' | 'category'> {
    categoryId: string;
}

export interface UpdateProductDto extends Partial<CreateProductDto> {

}

Tener en cuenta que cuando utilizamos CreateProductDTO tenemos omitidos el atributo updateAt que será necesario para el método de actualizar producto, en tonces al hacer lo siguiente:

export interface UpdateProductDTO extends Partial<CreateProductDTO> {}

estamos heredando la omisión de updateAt y para recuperar esto podemos hacer una extención de múltiple de lo que teníamos anteriormente más el atributo updateAt que será necesario cuando actualicemos nuestro producto:

export interface UpdateProductDTO extends Partial<CreateProductDTO>, Pick<Product, 'updateAt'> {}

De verdad que el curso de manipulación de arrays debe estar genial. Es lo que tomaré al finalizar acá.

Aprender todo esto de utility types me recuerda mucho a teoría de conjuntos, donde cada interface seria un conjunto y sus operaciones como intersecciones o uniones los utility types

Nos sirven para declarar que los datos que provienen de ese tipo o interfaz son opcionales, usualmente lo usamos al momento de modificar datos.

Imagina que tienes un producto, este producto al momento de ser creado obtuvo ciertos datos, pero ahora necesitas modificarlo, sin embargo no necesitas todos los datos para modificarlo ya que solo modificaras o cambiaras ciertos datos.

Entonces allí entra Partials

interface Product {
	id: number,
	name: string,
	color: string,
	description: string,
	model: string,
	country: string,
}

interface EditProduct extends Product Partial<Product>

Required

A diferencia de Partials que pone todos los datos como opcionales, tenemos también required que hace lo contrario, pone todos los datos como obligatorios.

en lugar del find puede ser un map.

const updateProduct = (id: string, payload: IUpdateProductDto) => {
    const updatedProducts = products.map(item => {
        return (item.id === id)? {...item, ...payload}: item
    })
    return updatedProducts
  }

En 8:52 Cuando se hace:

const prevData = productos[index]
products[index] = {
...prevData, ...changs
}

No es necesario el prevData, esta variable apunta al objeto en el array, no guarda una copia

Ya terminando la clase me perdi jejej
se confundio en el minuto 10

Lo que comentaba el profe sobre prevData y changes es muy importante en la vida real para no tener perdida de información y no tener que restaurar un respaldo de la base de datos. Si algo así te pasa y no tienes un respaldo… estas en problemas.
Aquí un pequeño ejemplo de lo que menciona el profe con una API con Express:

router.put('/:ID', verify, async function (req, res) {
    try {
        const { ID } = req.params
        const clientesJSON = { ...req.body, ID }

        const item = await service.updateClientes(clientesJSON)
        res.json({
            message: 'Test api updated',
            item,
        })
    } catch (error) {
        res.status(404).json({ message: error.message })
    }
})

Podemos hacer que los campos sean opcionales con Partial

export interface UpdateProductDto extends Partial<CreateProductDto> {}

Y podemos hacer que sean obligatorios con Required

type example2 = Required<Product>