findByIdAndUpdate is NOT Callable typescript (fails to execute on union type of Models)

[DVGY]

Do you want to request a feature or report a bug?
Bug
What is the current behavior?
This expression is not callable. findByIdAndUpdate

If the current behavior is a bug, please provide the steps to reproduce.

import Reviews, Users, Trips  from '../models/allModel';

type UserDefinedModel = typeof Reviews | typeof Users | typeof Trips;

export const updateOne = (userDefinedModel: UserDefinedModel): RequestHandler =>
  catchAsync(
    async (req: Request, res: Response, next: NextFunction): Promise<void> => {
      const { id } = req.params;

      const doc = await userDefinedModel.findByIdAndUpdate(id, req.body, {
        new: true,
        runValidators: true,
      });

      const modelName = userDefinedModel.modelName;

      if (!doc) {
        return next(new AppError(`No ${modelName} found with that Id`, 400));
      }

      res.status(200).json({
        status: 'success',
        [modelName]: { doc },
      });
    }
  );

I can share my private repo with the member of this repo. Let me know.

{
  "compilerOptions": {
    "target": "ES2018" /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */,
    "module": "commonjs" /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */,
    /* Concatenate and emit output to single file. */
    "outDir": "build" /* Redirect output structure to the directory. */,
    "rootDir": "src" /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */,
    /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
    "declaration": true,
    "stripInternal": true,

    /* Strict Type-Checking Options */
    "strict": true /* Enable all strict type-checking options. */,
    /* Parse in strict mode and emit "use strict" for each source file. */

    "esModuleInterop": true /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */,

    "skipLibCheck": true /* Skip type checking of declaration files. */,
    "forceConsistentCasingInFileNames": true /* Disallow inconsistently-cased references to the same file. */,
    "typeRoots": ["src/@types", "./node_modules/@types"]
  },
  "include": ["src"]
}

What is the expected behavior?

findByIdAndUpdate should be callable
find should be callable

If I replace userDefinedModel with specific model like Users.findByIdAndUpdate or Users.find(), it works.

What are the versions of Node.js, Mongoose and MongoDB you are using? Note that "latest" is not a version.
Node: 14.15.4, "mongoose": "^5.12.12", MongoDB 4.4

[IslandRhythms]

can you provide allModels?

[vkarpov15]

@DVGY without seeing what userDefinedModel looks like, we won't be able to repro this. Can you please provide a standalone script that demonstrates this issue?

[DVGY]

@DVGY without seeing what userDefinedModel looks like, we won't be able to repro this. Can you please provide a standalone script that demonstrates this issue?

@vkarpov15 @IslandRhythms Here is the codesandbox

code

Checkout the file src/models/updateOneController.ts

Thanks

[IslandRhythms]

import * as mongoose from "mongoose";
import * as express from "express";
enum UserRole {
  ADMIN = "ADMIN",
  LEAD_GUIDE = "LEAD_GUIDE",
  GUIDE = "GUIDE",
  USER = "USER"
}
interface IUsers extends mongoose.Document {
  name: string;
  email: string;
  password: string;
}

const usersSchema = new mongoose.Schema<IUsers>({
  name: {
    type: String,
    required: [true, "Please tell us your name"]
  },
  email: {
    type: String,
    required: [true, "Please tell us your name"],
    unique: true,
    lowercase: true
  },
  password: {
    type: String,
    required: [true, "Please enter a password"],
    minlength: 8,
    select: false
  }
});

//--------------------------------------------------//
//             PRE MIDDLEWARE                       //
//--------------------------------------------------//

const Users = mongoose.model<IUsers>("Users", usersSchema);


const tripsSchema = new mongoose.Schema<ITrips>({
    name: {
      type: String,
      required: [true, "A trip must have a name"],
      unique: true,
      trim: true,
      maxlength: [40, "A trip name must have less or equal then 40 characters"],
      minlength: [10, "A trip name must have more  or equal then 10 characters"]
    },
    slug: String,
    duration: {
      type: Number,
      required: [true, "A trip must have a duration"]
    },
    price: {
      type: Number,
      required: [true, "A trip must have a price"]
    }
  });
  
  //---------------------------------------------------//
  //--------------------INTERFACES---------------------//
  //--------------------------------------------------//
  
  interface ITrips extends mongoose.Document {
    name: string;
    slug: string;
    duration: number;
    price: number;
    priceDiscount: number;
    maxGroupSize: number;
    difficulty: string;
    ratingsAverage: number;
    ratingsQuantity: number;
    summary: string;
    description: string;
    imageCover: string;
  }
  
  //--------------------------------------------------//
  //             VIRTUALS                             //
  //--------------------------------------------------//
  
  //---------------------------------------------------//
  //                 METHODS                           //
  //---------------------------------------------------//
  
  const Trips = mongoose.model<ITrips>("Trips", tripsSchema);

  const reviewsSchema = new mongoose.Schema<IReviews>(
    {
      review: {
        type: String,
        require: [true, "Review cannot be empty"]
      },
      rating: {
        type: Number,
        min: 1,
        max: 5
      },
      createdAt: {
        type: Date,
        default: Date.now
      },
      trip: {
        type: mongoose.Schema.Types.ObjectId,
        ref: "Trips",
        required: [true, "Review must belong to a Trip"]
      },
      user: {
        type: mongoose.Schema.Types.ObjectId,
        ref: "Users",
        required: [true, "Review must belong to a User"]
      }
    },
    {
      toJSON: {},
      toObject: {}
    }
  );
  
  //---------------------------------------------------//
  //--------------------INTERFACES---------------------//
  //--------------------------------------------------//
  
  interface IReviews extends mongoose.Document {
    review: string;
    rating: number;
    createdAt: Date;
    trip: ITrips;
    user: IUsers;
  }
  
  const Reviews = mongoose.model<IReviews>("Reviews", reviewsSchema);
  


type UserDefinedModel = typeof Reviews | typeof Users | typeof Trips;

// Note
/**
 * findByIdAndUpdate() and find() is not callable on union of type different mongoose models
 *
 */

const updateOne = (
  // userDefinedModel: Model<any,{},{}> // This works
  userDefinedModel: UserDefinedModel // This does not
): express.RequestHandler => async (
  req: express.Request,
  res: express.Response,
  next: express.NextFunction
): Promise<void> => {
  const { id } = req.params;

  const doc = await userDefinedModel.findByIdAndUpdate(id, req.body, {
    new: true,
    runValidators: true
  });

  const doc2 = await userDefinedModel.find();

  const doc3 = await Reviews.findByIdAndUpdate();

  const modelName = userDefinedModel.modelName;

  if (!doc) {
    // Error
  }

  res.status(200).json({
    status: "success",
    [modelName]: { doc }
  });
};

[vkarpov15]

Unfortunately this looks like a limitation in TypeScript: microsoft/TypeScript#33591 . TS doesn't handle this sort of union type behavior well, we would recommend defining this as a static instead.

reviewsSchema.static('expressUpdateOne', async function(
  req: express.Request,
  res: express.Response,
  next: express.NextFunction
): Promise<void> {
  const Model = this;

  const { id } = req.params;

  const doc = await Model.findByIdAndUpdate(id, req.body, {
    new: true,
    runValidators: true
  });

  const doc2 = await userDefinedModel.find();

  const doc3 = await Model.findByIdAndUpdate();

  const modelName = Model.modelName;

  if (!doc) {
    // Error
  }

  res.status(200).json({
    status: "success",
    [modelName]: { doc }
  });
});

[DVGY]

@vkarpov15 this update one will run of different models too, I see here you are registering it on reviewSchema. Can I register it on Model ?

[vkarpov15]

@DVGY sure, you can structure it as a global plugin: https://mongoosejs.com/docs/plugins.html

[ibnlisha]

I got the same error and found out it was related to the model export.
const User = models.User? models.User :model<dbUser>('User', userSchema). Asserting the model type did the trick.
const User = models.User? models.User as Model<dbUser>:model<dbUser>('User', userSchema)