feat: provide discriminator models automatically

Author: Pong420

lib/mongoose.providers.ts

@@ -1,4 +1,4 @@
-import { flatten } from '@nestjs/common';
+import { Provider } from '@nestjs/common';
 import { Connection, Document, Model } from 'mongoose';
 import { getConnectionToken, getModelToken } from './common/mongoose.utils';
 import {
@@ -9,50 +9,68 @@ import {
 
 function addDiscriminators(
   model: Model<Document>,
-  discriminators?: DiscriminatorOptions[],
-) {
-  if (discriminators) {
-    for (const { name, schema } of discriminators) {
-      model.discriminator(name, schema);
-    }
-  }
-  return model;
+  discriminators: DiscriminatorOptions[] = [],
+): Model<Document>[] {
+  return discriminators.map(({ name, schema }) =>
+    model.discriminator(name, schema),
+  );
 }
 
 export function createMongooseProviders(
   connectionName?: string,
   options: ModelDefinition[] = [],
-) {
-  const providers = (options || []).map((option) => ({
-    provide: getModelToken(option.name),
-    useFactory: (connection: Connection) => {
-      const model = connection.model(
-        option.name,
-        option.schema,
-        option.collection,
-      );
-      return addDiscriminators(model, option.discriminators);
-    },
-    inject: [getConnectionToken(connectionName)],
-  }));
-  return providers;
+): Provider[] {
+  return options.reduce(
+    (providers, option) => [
+      ...providers,
+      ...createMongooseProviders(connectionName, option.discriminators),
+      {
+        provide: getModelToken(option.name),
+        useFactory: (connection: Connection) => {
+          const model = connection.model(
+            option.name,
+            option.schema,
+            option.collection,
+          );
+          addDiscriminators(model, option.discriminators);
+          return model;
+        },
+        inject: [getConnectionToken(connectionName)],
+      },
+    ],
+    [] as Provider[],
+  );
 }
 
 export function createMongooseAsyncProviders(
   connectionName?: string,
   modelFactories: AsyncModelFactory[] = [],
-) {
-  const providers = (modelFactories || []).map((option) => [
-    {
-      provide: getModelToken(option.name),
-      useFactory: async (connection: Connection, ...args: unknown[]) => {
-        const schema = await option.useFactory(...args);
-        const model = connection.model(option.name, schema, option.collection);
-        addDiscriminators(model, option.discriminators);
-        return model;
+): Provider[] {
+  return modelFactories.reduce((providers, option) => {
+    return [
+      ...providers,
+      {
+        provide: getModelToken(option.name),
+        useFactory: async (connection: Connection, ...args: unknown[]) => {
+          const schema = await option.useFactory(...args);
+          const model = connection.model(
+            option.name,
+            schema,
+            option.collection,
+          );
+          addDiscriminators(model, option.discriminators);
+          return model;
+        },
+        inject: [getConnectionToken(connectionName), ...(option.inject || [])],
       },
-      inject: [getConnectionToken(connectionName), ...(option.inject || [])],
-    },
-  ]);
-  return flatten(providers);
+      // discriminators must convert to `AsyncModelFactory`.
+      // Otherwise, the discriminators will register as `Model` before `model.discriminator` and throw OverwriteModelError
+      ...createMongooseAsyncProviders(
+        connectionName,
+        (option.discriminators || []).map<AsyncModelFactory>(
+          ({ name, schema }) => ({ name, useFactory: async () => schema }),
+        ),
+      ),
+    ];
+  }, [] as Provider[]);
 }