node.js - tipo de retorno de Elasticsearch

Estoy intentando simplemente recibir un elemento insertado, editarlo y actualizarlo de nuevo. Desafortunadamente, esto no va tan bien.

El código aún no está finalizado y solo se está probando como prueba de concepto, no lo uses así en producción si tienes intención de copiarlo :).

Mi función create que funciona bien:

async create(index: string, obj: any, id: string): Promise<TModel> {
    let req: RequestParams.Create<TModel> = {
        body: obj,
        index: index,
        id: id,
    };
    try {
        var result = await this.client.create(req, {
            ignore:[409]
        });
        if (result.statusCode === 201) {
            return result.body;
        } else {
            console.log("Non succesfull call, result:", result);
            return null;
        }
    } catch (error) {
        console.log("create error", error);
        return null;
    }
}

Mi función de actualización que funciona de manera similar

async update(index: string, obj: any, id: string): Promise<TModel> {
    try {
        let req: RequestParams.Update<TModel> = {
            body: obj,
            index: index,
            id: id
        };
        var result = await this.client.update(req);
        if (result.statusCode === 200 || result.statusCode === 201 || result.statusCode == 202 || result.statusCode == 204) {
            return result.body;
        } else {
            console.log("Non succesfull call, result:", result);
            return null;
        }
    } catch (error) {
        console.error("Error updating", error);
    }
}

La función de búsqueda con la que comencé:

async search(index: string, searchBody: any): Promise<any> {

    try {
        var result = await this.client.search({
            index: index,
            body: searchBody
        });
        if (result.statusCode === 200) {
            return result.body.hits.hits;
        } else {
            console.log("Non succesfull call, result:", result);
            return null;
        }
    } catch (error) {
        console.log("Error getting result", error);
        return null;
    }
}

Al insertar y posteriormente buscar un objeto, por supuesto obtienes un tipo de retorno any. Sabiendo cómo están estructurados los datos, en algún lugar hago lo siguiente solo para probar rápidamente:

return result.body.hits.hits[0]._source

Lo cual me da esto como resultado:

Aunque el formato JSON del objeto parece ser correcto, tal como lo he creado, genera un error al actualizar los datos:

Así que busqué en Google y traté de aplicar esta solución, proporcionada por los propios de Elastic:

https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/typescript.html

Código de búsqueda:

async searchTyped(index: string, searchBody: any): Promise<TModel> {
    try {
        let req : RequestParams.Search<TModel> ={
            index : index,
             body : searchBody,
        };
        var result : ApiResponse<SearchResponse<TModel>> = await this.client.search(req);
        if (result.statusCode === 200) {
            if(result.body.hits.hits.length > 0){
                return result.body.hits.hits[0]._source;
            }
            return null;
        } else {
            console.log("Non succesfull call, result:", result);
            return null;
        }
    } catch (error) {
        console.log("Error getting result", error);
        return null;
    }
}

Según Intellisense, esto debería funcionar, _source debería ser del tipo TModel.

Desafortunadamente, sin suerte:

¿Estoy en el camino correcto para asegurarme de que los objetos de datos sean correctos antes de actualizar?

Nos gustaría ceñirnos al mapeo dinámico y no definir el modelo exacto que se necesita. Supongo que con esta configuración realmente no importa si un cuerpo de solicitud contiene un Object de JavaScript o un tipo de TypeScript.

Respuesta #1

Eventualmente no importaba qué objeto era, solo tenía que hacer la actualización de manera diferente:

async update(index: string, obj: any, id: string): Promise<any> {
    try {
        let req: RequestParams.Update<any> = {
            body: {
                "doc": obj
            },
            index: index,
            id: id
        };
        var result = await this.client.update(req);
        if (result.statusCode === 200 || result.statusCode === 201 || result.statusCode == 202 || result.statusCode == 204) {
            return result.body;
        } else {
            console.log("Non succesfull call, result:", result);
            return null;
        }
    } catch (error) {
        console.error("Error updating", error);
    }
}

Entonces todas las actualizaciones deberían venir dentro de doc y luego todo está bien.

Encontrado en esta guía: https://hub.packtpub.com/crud-create-read-update-delete-operations-elasticsearch/