fix: enum rule for array element (#1)

.github/workflows/build.yml

@@ -24,18 +24,18 @@ jobs:
           node-version: 20
           registry-url: https://registry.npmjs.org/
       - name: Install dependencies
-        run: npm ci
+        run: npm install
       - name: Format
         run: |
-          UNFORMATTED_FILES=$(npm run format:check)
+          UNFORMATTED_FILES=$(npx nx format:check)
           if [ -n "$UNFORMATTED_FILES" ]; then
             echo "Unformatted files found:"
             echo "$UNFORMATTED_FILES"
             exit 1
           fi
       - name: Lint
-        run: npm run lint
+        run: npx nx affected -t lint
       - name: Build
-        run: npm run build
+        run: npx nx affected -t build
       - name: Test
-        run: npm run test
+        run: npx nx affected -t test

nx.json

@@ -7,7 +7,7 @@
   "extends": "nx/presets/npm.json",
   "$schema": "./node_modules/nx/schemas/nx-schema.json",
   "affected": {
-    "defaultBase": "main"
+    "defaultBase": "origin/main"
   },
   "release": {
     "projects": ["@mocking-bird/core", "@mocking-bird/mongoose"],

packages/core/src/core-fixture.ts

@@ -30,7 +30,7 @@ export abstract class CoreFixture<T> {
   protected constructor(
     pathfinder: CorePathFinder,
     typeMapper: CoreTypeMapper,
-    validator?: Validator
+    validator?: Validator,
   ) {
     this.pathfinder = pathfinder;
     this.typeMapper = typeMapper;
@@ -53,7 +53,7 @@ export abstract class CoreFixture<T> {
   abstract bulkGenerate(
     size: number,
     overrideValues?: Record<FieldPath, Value>,
-    options?: FixtureOptions
+    options?: FixtureOptions,
   ): T[];
 
   /**
@@ -66,7 +66,7 @@ export abstract class CoreFixture<T> {
    */
   abstract generate(
     overrideValues?: Record<FieldPath, Value>,
-    options?: FixtureOptions
+    options?: FixtureOptions,
   ): T;
 
   /**
@@ -91,7 +91,7 @@ export abstract class CoreFixture<T> {
     fieldName: string,
     type: NonArrayFieldType,
     rule: Rule | undefined,
-    isAccurate = true
+    isAccurate = true,
   ): Value {
     return this.fakerApi.generate(fieldName, type, rule, isAccurate);
   }
@@ -106,7 +106,8 @@ export abstract class CoreFixture<T> {
    *
    * @param fieldName The name of the field for which the value should be generated.
    * @param type The non array type of the field, i.e., only the based types.
-   * @param rule The rule to be used to generate the value.
+   * @param size The size of the array to be generated.
+   * @param rule The rule to use for the array element.
    * @param isAccurate If set to `true`, the value will be generated with the highest possible accuracy.
    *
    * @returns An array of mock values based on the given field name and type.
@@ -116,12 +117,13 @@ export abstract class CoreFixture<T> {
   protected generateArrayValue(
     fieldName: string,
     type: NonArrayFieldType,
+    size: number | undefined,
     rule: Rule | undefined,
-    isAccurate = true
+    isAccurate = true,
   ): Value[] {
-    if (rule?.size) {
-      return Array.from({ length: rule.size }, () =>
-        this.fakerApi.generate(fieldName, type, rule, isAccurate)
+    if (size) {
+      return Array.from({ length: size }, () =>
+        this.fakerApi.generate(fieldName, type, rule, isAccurate),
       );
     }
 

packages/mongoose/jest.config.ts

@@ -8,4 +8,5 @@ export default {
   },
   moduleFileExtensions: ['ts', 'js', 'html'],
   coverageDirectory: '../../coverage/packages/mongoose',
+  testTimeout: 30000,
 };

packages/mongoose/src/mongoose-fixture.ts

@@ -383,12 +383,17 @@ export class MongooseFixture<T> extends CoreFixture<T> {
     if (type === FieldType.ARRAY) {
       // caster is the schema type of the array elements, from which we can get the array type, e.g., String, Number, etc.
       const { caster } = schemaType as Schema.Types.Array;
-
       return caster?.instance
         ? this.generateArrayValue(
             fieldName,
             this.typeMapper.getArrayType(caster.instance),
-            combinedRule,
+            combinedRule?.size,
+            /**
+             * The parsed rule here is the rule for the array elements.
+             * @example
+             * const schema = new Schema({ values: [type: String, enum: ['A', 'B', 'C']] });
+             */
+            this.mongooseValidator.parseValidators(caster.validators),
             isAccurate,
           )
         : undefined;

packages/mongoose/src/mongoose-type-mapper.ts

@@ -46,8 +46,10 @@ export class MongooseTypeMapper extends CoreTypeMapper {
         return FieldType.UUID;
       case 'bigint':
         return FieldType.BIGINT;
-      case 'mixed':
       case 'map':
+        // TODO: support map type
+        throw new Error('Map type is not supported yet.');
+      case 'mixed':
       case 'schema':
         return FieldType.OBJECT;
       default:

packages/mongoose/test/models/enum-schema.ts

@@ -0,0 +1,16 @@
+import mongoose from 'mongoose';
+
+export enum Authors {
+  DOSTOEVSKY = 'DOSTOEVSKY',
+  NIEZTSHE = 'NIEZTSHE',
+  KAFKA = 'KAFKA',
+  TOLSTOY = 'TOLSTOY',
+  HEMINGWAY = 'HEMINGWAY',
+}
+
+export const AuthorSchema = new mongoose.Schema(
+  {
+    authors: [{ type: String, enum: Authors }],
+  },
+  { _id: false, timestamps: false },
+);

packages/mongoose/test/models/index.ts

@@ -1,2 +1,4 @@
 export * from './basic-model';
 export * from './nested-model';
+export * from './enum-schema';
+export * from './map-type-model';

packages/mongoose/test/models/map-type-model.ts

@@ -0,0 +1,60 @@
+import { model, Schema } from 'mongoose';
+
+export type UserAddress = Record<
+  string,
+  {
+    street: string;
+    buildingNo: number;
+  }[]
+>;
+
+export type UserInfo = Record<
+  string,
+  {
+    name: string;
+    age: number;
+    address: UserAddress;
+  }[]
+>;
+
+export interface IMapDocument {
+  userAddress: UserAddress[];
+  userInfo: UserInfo;
+  basicInfo: Record<string, string>;
+}
+
+export const MapDocumentSchema = new Schema({
+  userAddress: {
+    type: Schema.Types.Map,
+    of: [
+      new Schema({
+        street: { type: String },
+        buildingNo: { type: Number },
+      }),
+    ],
+  },
+  userInfo: {
+    type: Schema.Types.Map,
+    of: new Schema({
+      name: { type: String },
+      age: { type: Number },
+      address: {
+        type: Schema.Types.Map,
+        of: new Schema({
+          street: { type: String },
+          buildingNo: { type: Number },
+        }),
+      },
+    }),
+  },
+  basicInfo: {
+    type: Schema.Types.Map,
+    of: String,
+  },
+});
+
+export const MapModel = model<IMapDocument>(
+  'MapDocument',
+  MapDocumentSchema,
+  'MapDocuments',
+);

packages/mongoose/test/mongodb-integration.spec.ts

@@ -1,7 +1,7 @@
 import { MongoDBContainer } from '@testcontainers/mongodb';
 import * as mongoose from 'mongoose';
 import { MongooseFixture } from '../src';
-import { BasicModel, NestedModel } from './models';
+import { BasicModel, MapModel, NestedModel } from './models';
 
 describe('MongoDB Integration Test', () => {
   beforeAll(async () => {
@@ -50,4 +50,12 @@ describe('MongoDB Integration Test', () => {
     const error = nestedDoc.validateSync();
     expect(error).toBeUndefined();
   });
+
+  // TODO - Fix this test
+  it.skip('should save a document with a complex map type', async () => {
+    const fixture = new MongooseFixture(MapModel);
+    const mockData = fixture.generate();
+
+    expect(await MapModel.create(mockData)).not.toThrow();
+  });
 });

packages/mongoose/test/mongoose.spec.ts

@@ -1,5 +1,11 @@
 import { MongooseFixture } from '../src';
-import { NestedModel, BasicModel, IBasicDocument } from './models';
+import {
+  NestedModel,
+  BasicModel,
+  IBasicDocument,
+  Authors,
+  AuthorSchema,
+} from './models';
 
 describe('Mocking Bird - Mongoose', () => {
   const assertRequiredFields = (mock: IBasicDocument) => {
@@ -438,6 +444,16 @@ describe('Mocking Bird - Mongoose', () => {
     });
   });
 
+  describe('Schema with enums', () => {
+    it('should generate a mock with the correct enum value', () => {
+      const fixture = new MongooseFixture(AuthorSchema);
+      const { authors } = fixture.generate();
+
+      expect(authors).toHaveLength(1);
+      expect(Object.values(Authors).includes(authors[0])).toBe(true);
+    });
+  });
+
   describe('Global options', () => {
     beforeEach(() => {
       MongooseFixture.setGlobalOptions({