Automatically translateAliases() for queries and updates

[akash-gupt]

import {
  addModelToTypegoose,
  arrayProp,
  buildSchema,
  getModelForClass,
  index,
  mongoose,
  plugin,
  pre,
  prop,
  Ref,
} from '@typegoose/typegoose';



export class Product extends BaseModel<Product> {
  static readonly collectionName = 'Products';
  @prop({
    required: true,
    index: true,
    sparse: true,
    alias: 'name2',
  })
  name: string;

}

import { SchemaOptions } from 'mongoose';

export const schemaOptions: SchemaOptions = {
  strict: true,
  timestamps: true,
  selectPopulatedPaths: false,
  minimize: true,
  toJSON: {
    virtuals: true,
    getters: true,
    transform: (doc, ret, options) => {
      delete ret.deleted;
      delete ret.__v;
      delete ret._id;
    },
  },
  toObject: {
    virtuals: true,
    getters: true,
    transform: (doc, ret, options) => {
      delete ret.deleted;
      delete ret.__v;
      delete ret._id;
    },
  },
};

I am not able to run an update query

Debug log
Mongoose: Products.updateOne({ _id: ObjectId("5e6e2c2ea1e74d2362c593e3") }, { '$setOnInsert': { createdAt: new Date("Tue, 17 Mar 2020 15:13:57 GMT") }, '$set': { updatedAt: new Date("Tue, 17 Mar 2020 15:13:57 GMT") }}, {})

[AbdelrahmanHafez]

Mongoose currently doesn't support querying/updating with aliases.

Meanwhile, you can use Model.translateAliases(...)

'use strict';

const mongoose = require('./');
const { Schema } = mongoose;
const assert = require('assert');

mongoose.connect('mongodb://localhost:27017/test', { useNewUrlParser: true, useUnifiedTopology: true });

const userSchema = new Schema({
  name: { type: String, alias: 'nameAlias' }
});

const User = mongoose.model('User', userSchema);

async function run() {
  await User.deleteMany();

  const user = await User.create({ nameAlias: 'Hafez' });

  const filter = User.translateAliases({ nameAlias: 'Hafez' });
  const changes = User.translateAliases({ nameAlias: 'new name' });

  await User.updateOne(filter, changes);


  const updatedUser = await User.findOne({ _id: user._id });
  assert.equals(updatedUser.nameAlias, 'new name');
}


run().catch(console.error);

[mazyvan]

Waiting for this feature. It will be really useful.

[komarevtsevdn]

Yeah, waiting too

[frdel]

Please, this is such an easy fix and would be so helpful...

[AbdelrahmanHafez]

The team's resources are currently focused on other issues, PRs implementing this functionality are welcome.

[vishnupeas]

why does the update work for lower-level aliases and not for the top-level fields?

eg:

const moduleSchema = mongoose.Schema(
    {
        mt: { type: Number, required: true, alias: "type" },
        mp: { type: [Number], required: true, alias: "permissions" },
    }
)

const roleSchema = mongoose.Schema(
    {
        n: { type: String, required: true, alias: "name" },
        m: { type: [moduleSchema], required: true, alias: "modules" },
    }
)

now when i call findByIdAndUpdate, the data passed gets updated if data is

data = {
    n: "admin",
    m: {
        type: 2,
        permission: [1, 2, 3],
    },
}

and fails to update when if pass data as

data = {
    name: "HR",
    modules: {
        type: 2,
        permission: [1, 2, 3],
    },
}

[vishnupeas]

I also noticed translateAliases only changes the field values shallow and not does consider the aliases that are deeper nested, the same case as the findByIdAndUpdate function.