refactor: add splitter

src/helpers/Splitter.ts

@@ -0,0 +1,82 @@
+import { MetaModel, ReferenceModel, EnumModel, UnionModel, ArrayModel, TupleModel, StringModel, IntegerModel, FloatModel, BooleanModel, ObjectModel, DictionaryModel} from '../models';
+
+export type SplitOptions = {
+  splitEnum?: boolean,
+  splitUnion?: boolean,
+  splitArray?: boolean,
+  splitTuple?: boolean,
+  splitString?: boolean,
+  splitInteger?: boolean,
+  splitFloat?: boolean,
+  splitBoolean?: boolean,
+  splitObject?: boolean,
+  splitDictionary?: boolean
+}
+
+/**
+ * Try split the model
+ * @param model 
+ * @param options 
+ * @param models 
+ * @returns whether the new or old MetaModel to use.
+ */
+// eslint-disable-next-line sonarjs/cognitive-complexity
+const trySplitModel = (model: MetaModel, options: SplitOptions, models: MetaModel[]): MetaModel => {
+  const shouldSplit = options.splitEnum === true && model instanceof EnumModel ||
+    options.splitUnion === true && model instanceof UnionModel ||
+    options.splitArray === true && model instanceof ArrayModel ||
+    options.splitTuple === true && model instanceof TupleModel ||
+    options.splitString === true && model instanceof StringModel ||
+    options.splitInteger === true && model instanceof IntegerModel ||
+    options.splitFloat === true && model instanceof FloatModel ||
+    options.splitBoolean === true && model instanceof BooleanModel ||
+    options.splitObject === true && model instanceof ObjectModel ||
+    options.splitDictionary === true && model instanceof DictionaryModel;
+
+  if (shouldSplit) {
+    models.push(model);
+    return new ReferenceModel(model.name, model.originalInput, model);
+  } 
+  return model;
+};
+
+/**
+ * Overwrite the nested models with references where required.
+ * 
+ * @param model 
+ * @param options 
+ * @param models 
+ * @returns an array of all the split models
+ */
+export const split = (model: MetaModel, options: SplitOptions, models: MetaModel[] = [model]): MetaModel[] => {
+  if (model instanceof ObjectModel) {
+    for (const [prop, propModel] of Object.entries(model.properties)) {
+      model.properties[String(prop)] = trySplitModel(propModel, options, models);
+      split(propModel, options, models);
+    }
+  } else if (model instanceof UnionModel) {
+    for (let index = 0; index < model.union.length; index++) {
+      const unionModel = model.union[Number(index)];
+      model.union[Number(index)] = trySplitModel(unionModel, options, models);
+      split(unionModel, options, models);
+    }
+  } else if (model instanceof ArrayModel) {
+    const valueModel = model.valueModel;
+    model.valueModel = trySplitModel(valueModel, options, models);
+    split(valueModel, options, models);
+  } else if (model instanceof TupleModel) {
+    for (const tuple of model.tuple) {
+      const tupleModel = tuple.value;
+      tuple.value = trySplitModel(tupleModel, options, models);
+      split(tupleModel, options, models);
+    }
+  } else if (model instanceof DictionaryModel) {
+    const keyModel = model.key;
+    const valueModel = model.value;
+    model.key = trySplitModel(keyModel, options, models);
+    model.value = trySplitModel(valueModel, options, models);
+    split(keyModel, options, models);
+    split(valueModel, options, models);
+  }
+  return models;
+};

src/helpers/index.ts

@@ -2,3 +2,4 @@ export * from './FormatHelpers';
 export * from './TypeHelpers';
 export * from './NameHelpers';
 export * from './FileHelpers';
+export * from './Splitter';

test/helpers/Splitter.spec.ts

@@ -0,0 +1,50 @@
+import { split, SplitOptions } from '../../src/helpers';
+import { ObjectModel, ReferenceModel, StringModel } from '../../src/models';
+describe('Splitter', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+  test('should split models when asked for it', () => { 
+    const stringModel = new StringModel('testString', undefined);
+    const model = new ObjectModel('testObj', undefined, {
+      test: stringModel
+    });
+    const options: SplitOptions = {
+      splitString: true
+    };
+    const splittedModels = split(model, options);
+
+    const expectedObjectModel = model;
+    expectedObjectModel.properties['test'] = new ReferenceModel(stringModel.name, stringModel.originalInput, stringModel);
+
+    expect(splittedModels.length).toEqual(2);
+    expect(splittedModels[0] instanceof ObjectModel).toEqual(true);
+    expect(splittedModels[0]).toEqual(expectedObjectModel);
+    expect(splittedModels[1] instanceof StringModel).toEqual(true);
+  });
+  test('should not split models when not asked for', () => { 
+    const stringModel = new StringModel('testString', undefined);
+    const model = new ObjectModel('testObj', undefined, {
+      test: stringModel
+    });
+    const options: SplitOptions = {
+      splitString: false
+    };
+    const splittedModels = split(model, options);
+    expect(splittedModels.length).toEqual(1);
+
+    expect(splittedModels[0]).toEqual(model);
+  });
+  test('should not split models when asked for something else', () => { 
+    const stringModel = new StringModel('testString', undefined);
+    const model = new ObjectModel('testObj', undefined, {
+      test: stringModel
+    });
+    const options: SplitOptions = {
+      splitBoolean: true
+    };
+    const splittedModels = split(model, options);
+    expect(splittedModels.length).toEqual(1);
+    expect(splittedModels[0]).toEqual(model);
+  });
+});