fix: 🐛 allow to create documents with non-generated ids (#407)

Author: ghusse

src/adapters/mongoose.js

@@ -200,7 +200,12 @@ module.exports = (model, opts) => {
   });
 
   function getRequired(fieldInfo) {
-    return fieldInfo.isRequired === true;
+    return fieldInfo.isRequired === true
+      || (
+        fieldInfo.path === '_id'
+        && !fieldInfo.options.auto
+        && fieldInfo.options.type !== mongoose.Schema.ObjectId
+      );
   }
 
   function getValidations(fieldInfo) {

src/services/resource-creator.js

@@ -8,7 +8,12 @@ function ResourceCreator(Model, params) {
 
   function create() {
     return new P((resolve, reject) => {
-      if ('_id' in params) { delete params._id; }
+      const idField = schema.fields.find((field) => field.field === '_id');
+      const isAutomaticId = !idField || !idField.isRequired;
+
+      if ('_id' in params && isAutomaticId) {
+        delete params._id;
+      }
 
       new Model(params)
         .save((err, record) => {

test/tests/adapters/mongoose.test.js

@@ -677,7 +677,7 @@ describe('adapters > schema-adapter', () => {
     });
   });
 
-  describe('isRequired flag', () => {
+  describe('"isRequired" flag', () => {
     it('should be set to true', async () => {
       expect.assertions(2);
       const schema = new mongoose.Schema({
@@ -693,9 +693,37 @@ describe('adapters > schema-adapter', () => {
       expect(result).toHaveProperty('fields');
       expect(result.fields[0].isRequired).toStrictEqual(true);
     });
-  });
 
-  describe('"isRequired" flag', () => {
+    it('should be set to true for non-generated ids', async () => {
+      expect.assertions(2);
+      const schema = new mongoose.Schema({
+        _id: String,
+      });
+      const model = mongoose.model('WithNonGeneratedId', schema);
+
+      const result = await createSchemaAdapter(model, {
+        mongoose,
+        connections: [mongoose],
+      });
+      expect(result).toHaveProperty('fields');
+      expect(result.fields[0].isRequired).toStrictEqual(true);
+    });
+
+    it('should be set to false for generated ids', async () => {
+      expect.assertions(2);
+      const schema = new mongoose.Schema({
+        _id: mongoose.Schema.ObjectId,
+      });
+      const model = mongoose.model('WithGeneratedId', schema);
+
+      const result = await createSchemaAdapter(model, {
+        mongoose,
+        connections: [mongoose],
+      });
+      expect(result).toHaveProperty('fields');
+      expect(result.fields[0].isRequired).toBeUndefined();
+    });
+
     it('should not appear', async () => {
       expect.assertions(2);
       const schema = new mongoose.Schema({

test/tests/services/resources-creator.test.js

@@ -6,8 +6,9 @@ import mongooseConnect from '../../utils/mongoose-connect';
 
 describe('service > resources-creator', () => {
   let IslandModel;
+  let CityModel;
 
-  beforeAll(() => {
+  beforeAll(async () => {
     Interface.Schemas = {
       schemas: {
         Island: {
@@ -20,27 +21,50 @@ describe('service > resources-creator', () => {
             { field: 'population', type: 'Number' },
           ],
         },
+        City: {
+          name: 'City',
+          idField: '_id',
+          searchFields: ['name'],
+          fields: [
+            { field: '_id', type: 'String', isRequired: true },
+            { field: 'name', type: 'String' },
+            { field: 'population', type: 'Number' },
+          ],
+        },
       },
     };
 
-    return mongooseConnect()
-      .then(() => {
-        const IslandSchema = new mongoose.Schema({
-          name: {
-            type: String,
-            validate: {
-              validator: (v) => ['Kauai', 'Oahu', 'Haiti'].includes(v),
-              message: (props) => `${props.value} is not valid`,
-            },
-          },
-          population: {
-            type: Number,
-          },
-        });
+    await mongooseConnect();
+    const IslandSchema = new mongoose.Schema({
+      name: {
+        type: String,
+        validate: {
+          validator: (v) => ['Kauai', 'Oahu', 'Haiti'].includes(v),
+          message: (props) => `${props.value} is not valid`,
+        },
+      },
+      population: {
+        type: Number,
+      },
+    });
+
+    IslandModel = mongoose.model('Island', IslandSchema);
+    await IslandModel.deleteMany({});
+
+    const CitySchema = new mongoose.Schema({
+      _id: {
+        type: String,
+      },
+      name: {
+        type: String,
+      },
+      population: {
+        type: Number,
+      },
+    });
 
-        IslandModel = mongoose.model('Island', IslandSchema);
-        return IslandModel.deleteMany({});
-      });
+    CityModel = mongoose.model('City', CitySchema);
+    await CityModel.deleteMany({});
   });
 
   afterAll(() => mongoose.connection.close());
@@ -70,6 +94,14 @@ describe('service > resources-creator', () => {
     const result = await new ResourcesCreator(IslandModel, { _id: '56cb91bdc3464f14678934ca', name: 'Haiti' })
       .perform();
     expect(result).toHaveProperty('name', 'Haiti');
-    expect(result.id).not.toBe('56cb91bdc3464f14678934ca');
+    expect(result._id).not.toBe('56cb91bdc3464f14678934ca');
+  });
+
+  it('should not ignore _id for non-generated ids', async () => {
+    expect.assertions(2);
+    const result = await new ResourcesCreator(CityModel, { _id: '56cb91bdc3464f14678934ca', name: 'Lyon' })
+      .perform();
+    expect(result).toHaveProperty('name', 'Lyon');
+    expect(result._id).toBe('56cb91bdc3464f14678934ca');
   });
 });