Mongoose expire data but keep in database

I currently have data saving and expiring to/from a database via a mongoose schema like so:

var UserSchema = new Schema({
    createdAt: { type: Date, expires: '1m' },
    name: String,
    email: String
});

The only problem is that the document that’s saved to the database is completely removed from the database. How would I refactor the above so that the name/email address stay in the database but if the user attempts to login after their expiry date then they’re greeted with a message saying ‘session has expired, renew session’. (or something similar)

I’m wanting to do it this way because then if the user logs in with an expired email address the server is still able to lookup the email address and spit out a “expired session” message rather than a “not found” error which is what happens when data is deleted.

So to reiterate, how do I keep expired data in a mongo/mongoose database so the app is able to find the email address the user is attempting to login with but if their session has expired they need to renew the session?

You should use concept of Schema Reference for this. Save your expired field in another table and join your main user_table and expire_table(wxample name)

var UserSchema = new Schema({
    name: String,
    email: String
});

//save date by-default
//expire in 1 min as in your example
var expireSchema = new Schema({
    createdAt: { type: Date, default: Date.now, expires: '1m'  },
    user_pk: { type: Schema.Types.ObjectId, ref: 'user_expire'}
});

var userTable = mongoose.model('user_expire', UserSchema);
var expireTable = mongoose.model('expireMe', expireSchema);

//Save new user
var newUser =  new userTable({
    name: 'my_name',
    email: 'my_email'
});

newUser.save(function(err, result) {
    console.log(result, 'saved')
    var newExpire =  new expireTable({
        user_pk:result._id
    });
    //use _id of new user and save it to expire table
    newExpire.save(function(err, result) {
        console.log('saved relation')
    })
})

Now to detect whether session has expired or not

1. on executing this code before data gets expired

expireTable.findOne()
.populate('user_pk')
.exec(function (err, result) {
    if (err) throw err;
    console.log(result)
    if(result == null) {
        console.log('session has expired, renew session')
    } else {
        console.log('session is active')
    }
});

//output - session is active

2. on executing this code after data gets expired

expireTable.findOne()
.populate('user_pk')
.exec(function (err, result) {
    if (err) throw err;
    console.log(result)
    if(result == null) {
        console.log('session has expired, renew session')
    } else {
        console.log('session is active')
    }
});

//output - session has expired, renew session

The accepted answer is good, but with Mongo 3.0 and above, the

createdAt: { type: Date, default: Date.now, expires: '1m'  }

does not work for me.

Instead I used

var expireSchema = new Schema({
    expireAt: {
        type: Date,
        required: true,
        default: function() {
            // 60 seconds from now
            return new Date(Date.now() + 60000);
        }
    },
    user_pk: { type: Schema.Types.ObjectId, ref: 'user_expire'}
});

More info is here: Custom expiry times for mongoose documents in node js

EDIT

My comment above would also require invoking a Mongo function directly rather than via Mongoose syntax. This would be something like:

 db.[collection-name].createIndex( { "expireAt": 1 }, { expireAfterSeconds: 0 } )

Additionally this is for the Expire Documents at a Specific Clock Time way of doing a ttl field.

And I still can’t seem to get it to work, but might be because of the erratic way that the ttl reaper runs (once every 60 secs, but could be longer…)

EDIT

My issues were due to having an earlier incorrectly configured ttl index persisting on the expireAt field, this prevented my later (correctly defined) index from working. I fixed this just by deleting any non-_id earlier indexes and then re-adding my ttl index on the expireAt field.

Use db.[collection-name].getIndexes()

and

db.[collection-name].dropIndex({ "expireAt":1 }) to clear out before re-applying.

Also one other caveat – setting a Date snapshot in the default property of the expiredAt field means that the default value will always be a fixed date – instead set this Date value dynamically each time you create an instance of expireSchema:

var expireSchema = new Schema({
    expireAt: Date,
    user_pk: { type: Schema.Types.ObjectId, ref: 'user_expire' }
});

expireSchema
  .virtual('expiryTime')
  .get(function() {
    //allow for reaper running at 60 second intervals to cause expireAt.fromNow message to be 'in the past'
    var expiryTime = moment(this.expireAt).fromNow();
    if(String(expiryTime).indexOf("ago")){
      expiryTime = "in a few seconds";
    }
    return expiryTime;
  });

var expireModel =  mongoose.model('UserExpire', expireSchema);

expireModel.collection.ensureIndex( { "expireAt": 1 }, { expireAfterSeconds: 0 } );