aggiungere i campi Created_at e Updated_at agli schemi di mangusta

C'è un modo per aggiungere i campi create_at e updated_at a uno schema mongoose, senza doverli passare ogni volta che viene chiamato il nuovo MyModel ()?

Il campo Created_at sarebbe una data e aggiunto solo quando viene creato un documento. Il campo updated_at verrebbe aggiornato con una nuova data ogni volta che save () viene chiamato su un documento.

Ho provato questo nel mio schema, ma il campo non viene visualizzato se non lo aggiungo in modo esplicito:

var ItemSchema = new Schema({
    name    : { type: String, required: true, trim: true }
  , created_at    : { type: Date, required: true, default: Date.now }
});

A partire da Mongoose 4.0 è ora possibile impostare un'opzione timestamp sullo Schema per fare in modo che Mongoose gestisca questo per te:

var thingSchema = new Schema({..}, { timestamps: true });

È possibile modificare il nome dei campi utilizzati in questo modo:

var thingSchema = new Schema({..}, { timestamps: { createdAt: 'created_at' } });

http://mongoosejs.com/docs/guide.html#timestamps

AGGIORNAMENTO: (5 anni dopo)

Nota: se si decide di utilizzare Kappa Architecture ( Event Sourcing + CQRS ), non è necessario aggiornare la data. Dato che i tuoi dati sono un registro eventi immutabile e solo di append, hai sempre e solo bisogno della data di creazione dell'evento. Simile all'architettura Lambda , descritta di seguito. Quindi lo stato dell'applicazione è una proiezione del registro eventi (dati derivati). Se ricevi un evento successivo sull'entità esistente, utilizzerai la data di creazione dell'evento come data aggiornata per la tua entità. Questa è una pratica comunemente usata (e comunemente fraintesa) nei sistemi di microservizio.

AGGIORNAMENTO: (4 anni dopo)

Se usi ObjectIdcome _idcampo (che di solito è il caso), allora tutto ciò che devi fare è:

let document = {
  updatedAt: new Date(),
}

Controlla la mia risposta originale qui sotto su come ottenere il timestamp creato dal _idcampo. Se devi usare gli ID da un sistema esterno, controlla la risposta di Roman Rhrn Nesterov.

AGGIORNAMENTO: (2,5 anni dopo)

Ora puoi usare l' opzione #timestamps con la versione mongoose> = 4.0.

let ItemSchema = new Schema({
  name: { type: String, required: true, trim: true }
},
{
  timestamps: true
});

Se imposta timestamp, assegnazioni di mangusta createdAte updatedAtcampi al tuo schema, il tipo assegnato è Date.

Puoi anche specificare i nomi dei file di data e ora:

timestamps: { createdAt: 'created_at', updatedAt: 'updated_at' }

Nota: se stai lavorando su una grande applicazione con dati critici, dovresti riconsiderare l'aggiornamento dei tuoi documenti. Ti consiglierei di lavorare con dati immutabili, di sola aggiunta ( architettura lambda ). Ciò significa che permetti solo inserti. Aggiornamenti ed eliminazioni non dovrebbero essere consentiti! Se si desidera "eliminare" un record, è possibile inserire facilmente una nuova versione del documento con alcuni timestamp/ version archiviati e quindi impostare un deletedcampo su true. Allo stesso modo, se si desidera aggiornare un documento, ne si crea uno nuovo con i campi appropriati aggiornati e il resto dei campi copiati. Quindi, per interrogare questo documento, si otterrebbe quello con il timestamp più recente o la versione più alta che è non "cancellato" (ildeleted campo non definito o falso`).

L'immutabilità dei dati garantisce che i tuoi dati siano debuggabili: puoi tracciare la cronologia di ogni documento. Puoi anche ripristinare la versione precedente di un documento se qualcosa va storto. Se vai con una tale architettura ObjectId.getTimestamp()è tutto ciò di cui hai bisogno e non dipende da Mongoose.

RISPOSTA ORIGINALE:

Se si utilizza ObjectId come campo identità non è necessario il created_atcampo. Gli ObjectId hanno un metodo chiamato getTimestamp().

ObjectId ( "507c7f79bcf86cd7994f6c0e"). GetTimestamp ()

Ciò restituirà il seguente output:

Isodate ( "2012-10-15T21: 26: 17Z")

Maggiori informazioni qui Come posso estrarre la data di creazione da un Mongo ObjectID

Per aggiungere l' updated_atarchivio è necessario utilizzare questo:

var ArticleSchema = new Schema({
  updated_at: { type: Date }
  // rest of the fields go here
});

ArticleSchema.pre('save', function(next) {
  this.updated_at = Date.now();
  next();
});

Questo è quello che ho finito per fare:

var ItemSchema = new Schema({
    name    : { type: String, required: true, trim: true }
  , created_at    : { type: Date }
  , updated_at    : { type: Date }
});


ItemSchema.pre('save', function(next){
  now = new Date();
  this.updated_at = now;
  if ( !this.created_at ) {
    this.created_at = now;
  }
  next();
});

Utilizzare l' timestampsopzione integrata per lo schema.

var ItemSchema = new Schema({
    name: { type: String, required: true, trim: true }
},
{
    timestamps: true
});

Ciò aggiungerà automaticamente campi createdAte updatedAtal tuo schema.

http://mongoosejs.com/docs/guide.html#timestamps

Se usare update()ofindOneAndUpdate()

con {upsert: true}opzione

Puoi usare $setOnInsert

var update = {
  updatedAt: new Date(),
  $setOnInsert: {
    createdAt: new Date()
  }
};

Aggiungi timestampsa Schemaquesto quindi quindi createdAte updatedAtgenererà automaticamente per te

var UserSchema = new Schema({
    email: String,
    views: { type: Number, default: 0 },
    status: Boolean
}, { timestamps: {} });

Inoltre puoi cambiare createdAt -> created_atdi

timestamps: { createdAt: 'created_at', updatedAt: 'updated_at' }

È così che ho realizzato dopo aver creato e aggiornato.

Nel mio schema ho aggiunto il creato e aggiornato in questo modo:

   / **
     * Schema dell'articolo
     * /
    var ArticleSchema = new Schema ({
        creato: {
            tipo: data,
            impostazione predefinita: Date.now
        },
        aggiornato: {
            tipo: data,
            impostazione predefinita: Date.now
        },
        titolo: {
            tipo: stringa,
            predefinito: '',
            assetto: vero,
            richiesto: "Il titolo non può essere vuoto"
        },
        contenuto: {
            tipo: stringa,
            predefinito: '',
            assetto: vero
        },
        utente: {
            tipo: Schema.ObjectId,
            ref: 'Utente'
        }
    });

Quindi nel mio metodo di aggiornamento dell'articolo all'interno del controller dell'articolo ho aggiunto:

/ **
     * Aggiorna un articolo
     * /
    exports.update = function (req, res) {
        var articolo = req.article;

        articolo = _.extend (articolo, req.body);
        article.set ("aggiornato", Date.now ());

        article.save (function (err) {
            if (err) {
                return res.status (400) .send ({
                    messaggio: errorHandler.getErrorMessage (err)
                });
            } altro {
                res.json (articolo);
            }
        });
    };

Le sezioni in grassetto sono le parti di interesse.

var ItemSchema = new Schema({
    name : { type: String, required: true, trim: true }
});

ItemSchema.set('timestamps', true); // this will add createdAt and updatedAt timestamps

Documenti: https://mongoosejs.com/docs/guide.html#timestamps

È possibile utilizzare il timestampplug-in di mongoose-troopper aggiungere questo comportamento a qualsiasi schema.

Puoi usare questo plugin molto facilmente. Dai documenti:

var timestamps = require('mongoose-timestamp');
var UserSchema = new Schema({
    username: String
});
UserSchema.plugin(timestamps);
mongoose.model('User', UserSchema);
var User = mongoose.model('User', UserSchema)

E imposta anche il nome dei campi se desideri:

mongoose.plugin(timestamps,  {
  createdAt: 'created_at', 
  updatedAt: 'updated_at'
});

possiamo raggiungere questo obiettivo utilizzando anche il plug-in dello schema .

Nel helpers/schemaPlugin.jsfile

module.exports = function(schema) {

  var updateDate = function(next){
    var self = this;
    self.updated_at = new Date();
    if ( !self.created_at ) {
      self.created_at = now;
    }
    next()
  };
  // update date for bellow 4 methods
  schema.pre('save', updateDate)
    .pre('update', updateDate)
    .pre('findOneAndUpdate', updateDate)
    .pre('findByIdAndUpdate', updateDate);
};

e in models/ItemSchema.jsarchivio:

var mongoose = require('mongoose'),
  Schema   = mongoose.Schema,
  SchemaPlugin = require('../helpers/schemaPlugin');

var ItemSchema = new Schema({
  name    : { type: String, required: true, trim: true },
  created_at    : { type: Date },
  updated_at    : { type: Date }
});
ItemSchema.plugin(SchemaPlugin);
module.exports = mongoose.model('Item', ItemSchema);

Nello schema del modello, basta aggiungere un timestamp di un attributo e assegnargli un valore vero come mostrato: -

var ItemSchema = new Schema({
   name :  { type: String, required: true, trim: true },
},{timestamps : true}
);

const mongoose = require('mongoose');
const config = require('config');
const util = require('util');

const Schema = mongoose.Schema;
const BaseSchema = function(obj, options) {
  if (typeof(options) == 'undefined') {
    options = {};
  }
  if (typeof(options['timestamps']) == 'undefined') {
    options['timestamps'] = true;
  }

  Schema.apply(this, [obj, options]);
};
util.inherits(BaseSchema, Schema);

var testSchema = new BaseSchema({
  jsonObject: { type: Object }
  , stringVar : { type: String }
});

Ora puoi usarlo, in modo che non sia necessario includere questa opzione in ogni tabella

La mia versione di mangusta è la 4.10.2

Sembra che solo il gancio findOneAndUpdatesia lavoro

ModelSchema.pre('findOneAndUpdate', function(next) {
  // console.log('pre findOneAndUpdate ....')
  this.update({},{ $set: { updatedAt: new Date() } });
  next()
})

Utilizzare una funzione per restituire il valore predefinito calcolato:

var ItemSchema = new Schema({
    name: {
      type: String,
      required: true,
      trim: true
    },
    created_at: {
      type: Date,
      default: function(){
        return Date.now();
      }
    },
    updated_at: {
      type: Date,
      default: function(){
        return Date.now();
      }
    }
});

ItemSchema.pre('save', function(done) {
  this.updated_at = Date.now();
  done();
});

In realtà lo faccio nella parte posteriore

Se tutto va bene con l'aggiornamento:

 // All ifs passed successfully. Moving on the Model.save
    Model.lastUpdated = Date.now(); // <------ Now!
    Model.save(function (err, result) {
      if (err) {
        return res.status(500).json({
          title: 'An error occured',
          error: err
        });
      }
      res.status(200).json({
        message: 'Model Updated',
        obj: result
      });
    });

Utilizzare machinepack-datetime per formattare il datetime.

tutorialSchema.virtual('createdOn').get(function () {
    const DateTime = require('machinepack-datetime');
    let timeAgoString = "";
    try {
        timeAgoString = DateTime.timeFrom({
            toWhen: DateTime.parse({
                datetime: this.createdAt
            }).execSync(),
            fromWhen: new Date().getTime()
        }).execSync();
    } catch(err) {
        console.log('error getting createdon', err);
    }
    return timeAgoString; // a second ago
});

Il pacchetto macchina è fantastico con API chiare a differenza del mondo Javascript espresso o generale.

È possibile utilizzare middleware e virtual . Ecco un esempio per il tuo updated_atcampo:

ItemSchema.virtual('name').set(function (name) {
  this.updated_at = Date.now;
  return name;
});