Added option to use the label of the model as the definition name

Author: Richard Lay

lib/builder.js

@@ -239,6 +239,7 @@ internals.removeNoneSchemaOptions = function (options) {
         'reuseDefinitions',
         'uiCompleteScript',
         'deReference',
+        'dynamicDefinitionPrefix',
         'validatorUrl',
         'jsonEditor',
         'acceptToProduce',

lib/defaults.js

@@ -19,6 +19,7 @@ module.exports = {
     'uiCompleteScript': null,
     'xProperties': true,
     'reuseDefinitions': true,
+    'dynamicDefinitionPrefix': 'default',
     'deReference': false,
     'validatorUrl': '//online.swagger.io/validator',
     'acceptToProduce': true,  // internal, NOT public

lib/definitions.js

@@ -4,7 +4,9 @@ const Hash = require('../lib/hash');
 const Utilities = require('../lib/utilities');
 
 
-const internals = {};
+const internals = {
+    modelPrefixes: {}
+};
 
 exports = module.exports = internals.definitions = function (settings) {
 
@@ -44,11 +46,11 @@ internals.definitions.prototype.append = function (definitionName, definition, c
             out = definitionName;
         } else {
             // create new definition
-            out = internals.append(null, definition, currentCollection, settings);
+            out = internals.append(definitionName, definition, currentCollection, true, settings);
         }
     } else {
         // create new definition
-        out = internals.append(definitionName, definition, currentCollection, settings);
+        out = internals.append(definitionName, definition, currentCollection, false, settings);
     }
 
     return out;
@@ -64,7 +66,7 @@ internals.definitions.prototype.append = function (definitionName, definition, c
  * @param  {Object} settings
  * @return {String}
  */
-internals.append = function (definitionName, definition, currentCollection, settings) {
+internals.append = function (definitionName, definition, currentCollection, forceDynamicName, settings) {
 
     let out;
     let foundDefinitionName;
@@ -79,7 +81,17 @@ internals.append = function (definitionName, definition, currentCollection, sett
         out = foundDefinitionName;
     } else {
         // else create a new item using definitionName or next model number
-        out = definitionName || internals.nextModelName(currentCollection);
+        if (forceDynamicName) {
+            if (settings.dynamicDefinitionPrefix === 'useLabel') {
+                out = internals.nextModelName(definitionName + ' ', currentCollection);
+            }
+            else {
+                out = internals.nextModelName('Model ', currentCollection);
+            }
+        }
+        else {
+            out = definitionName || internals.nextModelName('Model ', currentCollection);
+        }
         currentCollection[out] = definition;
     }
     return out;
@@ -126,22 +138,22 @@ internals.hash = function (obj) {
 /**
  * creates a new unique model name
  *
+ * @param  {String} nextModelNamePrefix
  * @param  {Object} currentCollection
  * @return {String}
  */
-internals.nextModelName = function (currentCollection) {
-
+internals.nextModelName = function (nextModelNamePrefix, currentCollection) {
     let highest = 0;
     let key;
     for (key in currentCollection) {
-        if (Utilities.startsWith(key, 'Model')) {
-            let num = parseInt(key.replace('Model', ''), 10);
+        if (Utilities.startsWith(key, nextModelNamePrefix)) {
+            let num = parseInt(key.replace(nextModelNamePrefix, ''), 10) || 0;
             if (num && num > highest) {
                 highest = num;
             }
         }
     }
-    return 'Model ' + (highest + 1);
+    return nextModelNamePrefix + (highest + 1);
 };
 
 

lib/index.js

@@ -31,6 +31,7 @@ const schema = Joi.object({
     uiCompleteScript: Joi.string().allow(null),
     xProperties: Joi.boolean(),
     reuseDefinitions: Joi.boolean(),
+    dynamicDefinitionPrefix: Joi.string(),
     deReference: Joi.boolean(),
     validatorUrl: Joi.string().allow(null),
     acceptToProduce: Joi.boolean(),

test/Integration/definitions-test.js

@@ -190,6 +190,70 @@ lab.experiment('definitions', () => {
         });
     });
 
+    lab.test('dynamicDefinitionPrefix = useLabel', (done) => {
+
+        // use the label as a prefix for dynamic model names
+
+        const tempRoutes = [{
+            method: 'POST',
+            path: '/store1/',
+            config: {
+                handler: Helper.defaultHandler,
+                tags: ['api'],
+                validate: {
+                    payload: Joi.object({
+                        a: Joi.number(),
+                        b: Joi.number(),
+                        operator: Joi.string(),
+                        equals: Joi.number()
+                    }).label('A')
+                }
+            }
+        }, {
+            method: 'POST',
+            path: '/store2/',
+            config: {
+                handler: Helper.defaultHandler,
+                tags: ['api'],
+                validate: {
+                    payload: Joi.object({
+                        c: Joi.number(),
+                        v: Joi.number(),
+                        operator: Joi.string(),
+                        equals: Joi.number()
+                    }).label('A A')
+                }
+            }
+        }, {
+            method: 'POST',
+            path: '/store3/',
+            config: {
+                handler: Helper.defaultHandler,
+                tags: ['api'],
+                validate: {
+                    payload: Joi.object({
+                        c: Joi.number(),
+                        f: Joi.number(),
+                        operator: Joi.string(),
+                        equals: Joi.number()
+                    }).label('A')
+                }
+            }
+        }];
+
+        Helper.createServer({ dynamicDefinitionPrefix: 'useLabel' }, tempRoutes, (err, server) => {
+
+            expect(err).to.equal(null);
+            server.inject({ method: 'GET', url: '/swagger.json' }, function (response) {
+
+                expect(response.statusCode).to.equal(200);
+                expect(response.result.definitions.A).to.exist();
+                expect(response.result.definitions['A A']).to.exist();
+                expect(response.result.definitions['A 1']).to.exist();
+                Helper.validate(response, done, expect);
+            });
+        });
+    });
 
     lab.test('test that optional array is not in swagger output', (done) => {