rellenar campo de documento en getter

21 Jul, 2023 Programación 0

Estoy tratando de resolver un problema en el que hay dos campos en un esquema que pueden entrar en conflicto entre sí. Así que un campo puede ser válido, pero una vez que consideras el otro, ya no lo es. No tiene sentido combinar estos dos por varias razones.

Como resultado, tenemos la opción de manejar esa comparación en el cliente o implementar algo de nivel inferior para filtrar los documentos inválidos. es decir,

const schema = new Schema({
  isValid: Boolean,
  other: {
    isValid: Boolean
  }
})

si un documento no es válido, se considera indefinido.

// supongamos que estos son los contenidos de la colección
const Raw = [
  {
     isValid: true,
     other: {
        isValid: true
     }
  },
  {
     isValid: false,
     other: {
        isValid: true
     }
  },
  {
     isValid: true,
     other: {
        isValid: false
     }
  },
]

const data = await schema.find({});
data.length === 1; // true
data[0] === Raw[0]; // true

Es decir, estoy tratando de implementar un método para verificar si un documento es válido cada vez que se solicita. En este caso particular, sin embargo, other es en cambio una identificación de una colección diferente. Así que, para determinar si es válido, tendría que poblarlo.

¿Cuál es la mejor manera de hacer eso?

davy.ai

July 21, 2023 at 6:57 am

Para implementar un getter para validar documentos con campos conflictivos en un esquema de mongoose, puedes utilizar una combinación de virtuales y getters.

Primero, puedes definir un virtual para el campo ‘other’ que recupera el documento referenciado de la otra colección:

const schema = new Schema({
  isValid: Boolean,
  other: {
    type: Schema.Types.ObjectId,
    ref: 'OtherSchema'
  }
});

schema.virtual('otherDoc', {
  ref: 'OtherSchema',
  localField: 'other',
  foreignField: '_id',
  justOne: true
});

Luego, puedes definir un getter que verifica la validez del documento basado en el campo ‘isValid’ y el campo ‘isValid’ del documento referenciado:

schema.path('isValid').get(function(isValid) {
  if (this.other) {
    const otherDoc = this.otherDoc;
    if (otherDoc && otherDoc.isValid) {
      return isValid;
    }
    return undefined;
  }
  return isValid;
});

Este getter verifica si el campo ‘isValid’ es verdadero y, si ‘other’ está definido, recupera el documento referenciado y verifica si su campo ‘isValid’ también es verdadero. Si ambos campos son válidos, el getter devuelve el valor original de ‘isValid’. De lo contrario, devuelve indefinido.

Ahora, al consultar el esquema, el getter verificará automáticamente la validez de cada documento:

const data = await schema.find({});
data.length === 1; // true
data[0].isValid === true; // true

Si prefieres omitir por completo los documentos no válidos, también puedes definir un middleware pre-find que filtre los documentos con campos ‘isValid’ indefinidos:

schema.pre('find', function() {
  this.where({ isValid: { $ne: undefined } });
});

Este middleware eliminará todos los documentos con campos ‘isValid’ indefinidos antes de que se ejecute la operación de búsqueda.

Al combinar virtuales, getters y middlewares, puedes implementar una solución flexible para validar documentos de mongoose con campos conflictivos.

Answer

davy.ai

July 21, 2023 at 6:57 am
Para implementar un getter para validar documentos con campos conflictivos en un esquema de mongoose, puedes utilizar una combinación de virtuales y getters.

Primero, puedes definir un virtual para el campo ‘other’ que recupera el documento referenciado de la otra colección:
```
const schema = new Schema({
  isValid: Boolean,
  other: {
    type: Schema.Types.ObjectId,
    ref: 'OtherSchema'
  }
});

schema.virtual('otherDoc', {
  ref: 'OtherSchema',
  localField: 'other',
  foreignField: '_id',
  justOne: true
});
```
Luego, puedes definir un getter que verifica la validez del documento basado en el campo ‘isValid’ y el campo ‘isValid’ del documento referenciado:
```
schema.path('isValid').get(function(isValid) {
  if (this.other) {
    const otherDoc = this.otherDoc;
    if (otherDoc && otherDoc.isValid) {
      return isValid;
    }
    return undefined;
  }
  return isValid;
});
```
Este getter verifica si el campo ‘isValid’ es verdadero y, si ‘other’ está definido, recupera el documento referenciado y verifica si su campo ‘isValid’ también es verdadero. Si ambos campos son válidos, el getter devuelve el valor original de ‘isValid’. De lo contrario, devuelve indefinido.

Ahora, al consultar el esquema, el getter verificará automáticamente la validez de cada documento:
```
const data = await schema.find({});
data.length === 1; // true
data[0].isValid === true; // true
```
Si prefieres omitir por completo los documentos no válidos, también puedes definir un middleware pre-find que filtre los documentos con campos ‘isValid’ indefinidos:
```
schema.pre('find', function() {
  this.where({ isValid: { $ne: undefined } });
});
```
Este middleware eliminará todos los documentos con campos ‘isValid’ indefinidos antes de que se ejecute la operación de búsqueda.

Al combinar virtuales, getters y middlewares, puedes implementar una solución flexible para validar documentos de mongoose con campos conflictivos.

Comments are closed.

es.davy.ai

¿Tienes una pregunta?

rellenar campo de documento en getter

Answer

davy.ai