Incorrect inferred return type for distinct() on array fields

[richardsimko]

Prerequisites

• I have written a descriptive issue title
• I have searched existing issues to ensure the bug has not already been reported

Mongoose version

8.0.0

Node.js version

20.0.0

MongoDB server version

6.0

Typescript version (if applicable)

latest

Description

The inferred return type for distinct() queries with an array fields is incorrect. It's inferred to be string[][] for a string[] field when in fact it should be string[]

Steps to Reproduce

interface Foo {
  bar: string[];
}

const FooModel = model<Foo>('Foo', new Schema<Foo>({ bar: [String] }));

await FooModel.create({ bar: ['a', 'b'] })

const distinctBar = await FooModel.distinct('bar');
console.log(distinctBar); // [ 'a', 'b' ]

distinctBar is actually a string[] but the inferred return type is string[][].

Expected Behavior

Inferred return type does not add Array to a type which is already an Array

[donoftime2018]

distinct is actually returning an array of String arrays. bar is a String[] and distinct selects all unique String arrays within an array. So since distinct is returning an array of String arrays with one item it'll look something like this:

[
bar: []
]

[richardsimko]

@donoftime2018 No, distinct() returns an array of strings when run on a field with string[] type. See the Mongo docs. I've confirmed this is the case for mongoose as well.

Here's an amended example:

interface Foo {
  bar: string[];
}

const FooModel = model<Foo>('Foo', new Schema<Foo>({ bar: [String] }));

await FooModel.create({ bar: ['a', 'b'] })

const distinctBar = await FooModel.distinct('bar');
console.log(distinctBar); // [ 'a', 'b' ]

I've edited the description as well to explain this

[donoftime2018]

Try adding more documents to the collection so you can see what I am talking about or updating your version of mongoose

[IslandRhythms]

Upon further testing comes back as string[][]

import * as mongoose from 'mongoose';

interface Foo {
  bar: string[];
}

const FooModel = mongoose.model<Foo>('Foo', new mongoose.Schema<Foo>({ bar: [String] }));

async function run() {
  await mongoose.connect('mongodb://localhost:27017');
  await mongoose.connection.dropDatabase();
  await FooModel.create({ bar: ['a', 'b'] })
  await FooModel.create({ bar: ['c','d']});
  await FooModel.create({ bar: ['e','f']})

  const distinctBar = await FooModel.distinct('bar');
  console.log(distinctBar); // [ 'a', 'b', 'c', 'd', 'e', 'f' ]
}

run();

[donoftime2018]

Shall I report this as a bug?

[richardsimko]

@donoftime2018 That does sound like a separate bug, yes. I couldn't find anything in neither the mongo nor mongoose docs pointing to the behavior you mentioned being correct. As @IslandRhythms mentioned the type is string[][] even when the returned value is string[] (Thanks for confirming :) )

[donoftime2018]

Np

[donoftime2018]

https://www.mongodb.com/docs/manual/reference/method/db.collection.distinct/#std-label-distinct-method-behavior-array is the link I used

[IslandRhythms]

@donoftime2018 please open a new issue and follow the template if you have a bug to report.

[donoftime2018]

How?

[IslandRhythms]

From this page on the top right next to this issue title you should see a new issue button.

[donoftime2018]

I wanna take a go and fix this issue via code so what should I do?

[donoftime2018]

import * as mongoose from 'mongoose';
import { type } from 'os';

interface Foo {
bar: String;
bar_num: Number;
}

const FooModel = mongoose.model('Foo', new mongoose.Schema({ bar: [String], bar_num: [Number] }));

async function run() {
await mongoose.connect('mongodb://localhost:27017');
await mongoose.connection.dropDatabase();
await FooModel.create({ bar: ['a', 'b'], bar_num: [0, 2]})
await FooModel.create({ bar: ['c','d'], bar_num: [1, 2] });
await FooModel.create({ bar: ['e','f'], bar_num: [5]})

const distinctBar = await FooModel.distinct('bar');
const distinctBars = await FooModel.distinct('bar_num');
console.log(distinctBar); // [ 'a', 'b', 'c', 'd', 'e', 'f' ]
console.log(distinctBars); // [0, 1, 2 5]
//distinctBar is String[] and distinctBars is Number[]
}

run();

The inferred types are String[] and Number[] after removing the array brackets from interface Foo