Added ability to define properties of 'index' function in Schema decorator.

Author: benoitlahoz

packages/mongo/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assemblerjs/mongo",
-  "version": "0.9.1",
+  "version": "0.9.2",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",

packages/mongo/src/decorators/decorators.spec.ts

@@ -5,6 +5,7 @@ import { Prop } from './prop.decorator';
 import { Schema } from './schema.decorator';
 import { ModelFactory } from './factories/model.factory';
 import { isMongoRunning, startMongo, stopMongo, whichMongo } from '@/utils';
+import { create } from 'domain';
 
 @Schema({
   timestamps: true,
@@ -14,6 +15,10 @@ import { isMongoRunning, startMongo, stopMongo, whichMongo } from '@/utils';
       options: { deletedBy: true },
     },
   ],
+  index: {
+    fields: { name: 1, email: 1 },
+    options: { unique: true, partialFilterExpression: { name: true } },
+  },
 })
 export class Pattern {
   @Prop()
@@ -24,16 +29,19 @@ export class Pattern {
 
   @Prop({ type: String, required: true })
   public description: string;
+
+  @Prop({ unique: true, default: false })
+  public default: boolean;
 }
 
 const PatternModel = ModelFactory.createForClass(Pattern);
 
 const STOP_AT_END = true;
-const CLEAR_AT_END = false;
+const CLEAR_AT_END = true;
 
-const HOST = 'localhost';
+const HOST = '127.0.0.1';
 const PORT = 33333;
-const DB_NAME = 'decorators';
+const DB_NAME = 'assemblerjs-mongo-test';
 const DB = `${process.cwd()}/test-db/${DB_NAME}/data`;
 const LOGS = `${process.cwd()}/test-db/${DB_NAME}/logs/mongo/mongo.log`;
 
@@ -43,9 +51,21 @@ describe('Schema', () => {
     if ((await whichMongo()) === null)
       throw new Error(`Mongo is not installed.`);
 
-    const runningOrError = await isMongoRunning();
+    let runningOrError = await isMongoRunning();
     if (runningOrError instanceof Error) throw runningOrError;
 
+    if (runningOrError) {
+      // If Mongo is running, we stop it.
+      const stoppedOrError: boolean | Error = await stopMongo();
+      if (stoppedOrError instanceof Error) {
+        throw stoppedOrError;
+      }
+      expect(stoppedOrError).toBeTruthy();
+      await new Promise((resolve) => setTimeout(resolve, 2000));
+      expect(await isMongoRunning()).toBeFalsy();
+      runningOrError = false;
+    }
+
     if (!runningOrError) {
       const runOrError: string | Error = await startMongo({
         bindIp: [HOST],
@@ -59,15 +79,13 @@ describe('Schema', () => {
         throw runOrError;
       }
     }
-
-    await mongoose.connect(`mongodb://${HOST}:${PORT}`, {
-      dbName: DB_NAME,
-    });
+    await mongoose.connect(`mongodb://${HOST}:${PORT}/${DB_NAME}`);
 
     const created = await PatternModel.create({
       description: 'An user.',
       name: 'John Doe',
       email: 'john@doe.com',
+      default: true,
     });
     expect(created).toBeDefined();
 

packages/mongo/src/decorators/factories/model.factory.ts

@@ -17,10 +17,14 @@ export class ModelFactory {
     target: Function
   ): mongoose.Model<TClass> {
     const schemaDefinition = DefinitionsFactory.createForClass(target);
+
     const schemaMetadata =
       TypeMetadataStorage.getSchemaMetadataByTarget(target);
     const schemaOpts = schemaMetadata?.options;
 
+    const index = schemaOpts?.index;
+    delete schemaOpts?.index;
+
     const schema = new mongoose.Schema<TClass>(
       schemaDefinition as mongoose.SchemaDefinition<
         mongoose.SchemaDefinitionType<TClass>
@@ -35,6 +39,11 @@ export class ModelFactory {
       });
     }
 
+    if (index) {
+      // Add index to the schema.
+      schema.index(index.fields, index.options);
+    }
+
     return mongoose.model<TClass>(schemaOpts?.name || target.name, schema);
   }
 }

packages/mongo/src/decorators/factories/schema.factory.ts

@@ -4,6 +4,7 @@ import { forOf } from '@assemblerjs/core';
 import { TypeMetadataStorage } from '../storages/type-metadata.storage';
 import { DefinitionsFactory } from './definitions.factory';
 
+// FIXME/ This is never used???
 export class SchemaFactory {
   /**
    * Create a mongoose `Schema`.

packages/mongo/src/decorators/metadata/index.ts

@@ -1,3 +1,4 @@
+import { IndexDefinition, IndexOptions } from 'mongoose';
 import { PropOptions } from '../prop.decorator';
 import { SchemaOptions } from '../schema.decorator';
 
@@ -7,8 +8,15 @@ export interface PropertyMetadata {
   options: PropOptions;
 }
 
+export interface ExtendedSchemaOptions extends SchemaOptions {
+  index?: {
+    fields: IndexDefinition;
+    options?: IndexOptions;
+  };
+}
+
 export interface SchemaMetadata {
   target: Function;
-  options?: SchemaOptions;
+  options?: ExtendedSchemaOptions;
   properties?: PropertyMetadata[];
 }

packages/mongo/src/decorators/schema.decorator.ts

@@ -1,12 +1,13 @@
 import mongoose from 'mongoose';
 import { TypeMetadataStorage } from './storages/type-metadata.storage';
+import { ExtendedSchemaOptions } from './metadata';
 
 export interface SchemaOptions extends mongoose.SchemaOptions {
   name?: string;
   plugins?: Array<{ package: Function; options?: any }>; // TODO: Correct type.
 }
 
-export const Schema = (options?: SchemaOptions): ClassDecorator => {
+export const Schema = (options?: ExtendedSchemaOptions): ClassDecorator => {
   return (target: Function) => {
     TypeMetadataStorage.addSchemaMetadata({
       target,