adicione os campos created_at e updated_at aos esquemas de mangusto

Existe uma maneira de adicionar campos created_at e updated_at a um esquema de mangusto, sem precisar passá-los sempre que novo MyModel () for chamado?

O campo created_at seria uma data e somente será adicionado quando um documento for criado. O campo updated_at será atualizado com nova data sempre que save () for chamado em um documento.

Eu tentei isso no meu esquema, mas o campo não aparece, a menos que eu o inclua exccitly:

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

No Mongoose 4.0, agora você pode definir uma opção de registro de data e hora no esquema para que o Mongoose lide com isso para você:

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

Você pode alterar o nome dos campos usados ​​da seguinte maneira:

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

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

ATUALIZAÇÃO: (5 anos depois)

Nota: Se você decidir usar a Arquitetura Kappa ( Event Sourcing + CQRS ), não precisará da data atualizada. Como seus dados são um log de eventos imutável e somente anexável, você só precisa da data de criação do evento. Semelhante à arquitetura Lambda , descrita abaixo. Então o estado do seu aplicativo é uma projeção do log de eventos (dados derivados). Se você receber um evento subsequente sobre a entidade existente, usará a data de criação desse evento como data atualizada para sua entidade. Essa é uma prática comumente usada (e geralmente mal compreendida) em sistemas de microsserviços.

ATUALIZAÇÃO: (4 anos depois)

Se você usa ObjectIdcomo seu _idcampo (que geralmente é o caso), tudo que você precisa fazer é:

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

Verifique minha resposta original abaixo sobre como obter o carimbo de data e hora criado no _idcampo. Se você precisar usar IDs de um sistema externo, verifique a resposta de Roman Rhrn Nesterov.

ATUALIZAÇÃO: (2,5 anos depois)

Agora você pode usar a opção #timestamps com a versão mangusto> = 4.0.

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

Se definir carimbos de data e hora, mangusto createdAte updatedAtcampos para seu esquema, o tipo designado é Date.

Você também pode especificar os nomes dos arquivos de data e hora:

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

Nota: Se você estiver trabalhando em um grande aplicativo com dados críticos, reconsidere a atualização de seus documentos. Eu recomendaria que você trabalhasse com dados imutáveis ​​e somente anexáveis ( arquitetura lambda ). O que isso significa é que você só permite inserções. Atualizações e exclusões não devem ser permitidas! Se você quiser "excluir" um registro, poderá inserir facilmente uma nova versão do documento com alguns timestamp/ version arquivados e, em seguida, defina um deletedcampo como true. Da mesma forma, se você deseja atualizar um documento - você cria um novo com os campos apropriados atualizados e o restante dos campos copiados. Então, para consultar este documento, você obtém o que possui o carimbo de data / hora mais recente ou a versão mais alta que é não "excluído" (odeleted campo indefinido ou falso`).

A imutabilidade dos dados garante que seus dados sejam depuráveis ​​- você pode rastrear o histórico de todos os documentos. Você também pode reverter para a versão anterior de um documento se algo der errado. Se você optar por uma arquitetura desse tipo, ObjectId.getTimestamp()é tudo o que precisa e não depende do Mongoose.

RESPOSTA ORIGINAL:

Se você estiver usando o ObjectId como seu campo de identidade, não precisará do created_atcampo. Os ObjectIds têm um método chamado getTimestamp().

ObjectId ("507c7f79bcf86cd7994f6c0e"). GetTimestamp ()

Isso retornará a seguinte saída:

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

Mais informações aqui Como extrair a data criada de um Mongo ObjectID

Para adicionar updated_atarquivos, você precisa usar o seguinte:

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();
});

Isto é o que acabei fazendo:

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();
});

Use a timestampsopção interna para o seu esquema.

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

Isto irá adicionar automaticamente createdAte updatedAtcampos ao esquema.

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

Se usar update()oufindOneAndUpdate()

com {upsert: true}opção

você pode usar $setOnInsert

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

Adicione timestampsao seu Schemagosto assim createdAte updatedAtgerará automaticamente para você

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

Além disso, você pode mudar createdAt -> created_atpor

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

Foi assim que consegui ter criado e atualizado.

Dentro do meu esquema, adicionei o criado e atualizado da seguinte forma:

   / **
     * Esquema do artigo
     * /
    var ArticleSchema = novo esquema ({
        criada: {
            tipo: Data,
            padrão: Date.now
        }
        Atualizada: {
            tipo: Data,
            padrão: Date.now
        }
        title: {
            tipo: String,
            padrão: '',
            trim: true,
            obrigatório: 'O título não pode ficar em branco'
        }
        conteúdo: {
            tipo: String,
            padrão: '',
            trim: true
        }
        do utilizador: {
            tipo: Schema.ObjectId,
            ref: 'Usuário'
        }
    });

Em seguida, no meu método de atualização de artigo dentro do controlador de artigo, adicionei:

/ **
     * Atualize um artigo
     * /
    imports.update = função (req, res) {
        var artigo = req.article;

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

        article.save (function (err) {
            if (err) {
                return res.status (400) .send ({
                    mensagem: errorHandler.getErrorMessage (err)
                });
            } outro {
                res.json (artigo);
            }
        });
    };

As seções em negrito são as partes de interesse.

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

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

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

Você pode usar o timestampplug - in de mongoose-trooppara adicionar esse comportamento a qualquer esquema.

Você pode usar este plugin com muita facilidade. Dos documentos:

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 também defina o nome dos campos, se desejar:

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

podemos conseguir isso usando o plugin de esquema também.

No helpers/schemaPlugin.jsarquivo

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 no models/ItemSchema.jsarquivo:

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);

No esquema do modelo, basta adicionar um registro de data e hora do atributo e atribuir um valor verdadeiro a ele, conforme mostrado: -

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 }
});

Agora você pode usar isso, para que não haja necessidade de incluir essa opção em todas as tabelas

Minha versão do mangusto é 4.10.2

Parece que apenas o gancho findOneAndUpdateé trabalho

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

Use uma função para retornar o valor padrão calculado:

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();
});

Na verdade, eu faço isso nas costas

Se tudo correr bem com a atualização:

 // 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
      });
    });

Use machinepack-datetime para formatar o 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
});

O pacote de máquinas é ótimo com API clara, diferente do mundo Javascript expresso ou geral.

Você pode usar middleware e virtuais . Aqui está um exemplo para o seu updated_atcampo:

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