@strapi/typescript-utils 0.0.0-next.c58b405b44c71a93df733024d1f15c069cb6bdca → 0.0.0-next.c5f067b5650921187770124e9b6c8186e805e242

package/.eslintignore

@@ -1,2 +1,3 @@
 node_modules/
 .eslintrc.js
+index.d.ts

package/index.d.ts

@@ -0,0 +1,5 @@
+// FIXME: to remove when migrating this package to ts
+declare module '@strapi/typescript-utils' {
+  const utils: any;
+  export = utils;
+}

package/jest.config.js

@@ -2,4 +2,5 @@
 
 module.exports = {
   preset: '../../../jest-preset.unit.js',
+  displayName: 'Typescript utils',
 };

package/lib/__tests__/generators/schemas/attributes.test.js

@@ -1,22 +1,22 @@
 'use strict';
 
-jest.mock('../../../generators/schemas/imports', () => ({ addImport: jest.fn() }));
+jest.mock('../../../generators/common/imports', () => ({ addImport: jest.fn() }));
 
 const consoleWarnMock = jest.spyOn(console, 'warn').mockImplementation();
 
 const ts = require('typescript');
 
-const attributeToPropertySignature = require('../../../generators/schemas/attributes');
+const attributeToPropertySignature = require('../../../generators/common/models/attributes');
 const {
   getAttributeType,
   getAttributeModifiers,
-} = require('../../../generators/schemas/attributes');
-const { addImport } = require('../../../generators/schemas/imports');
+} = require('../../../generators/common/models/attributes');
+const { addImport } = require('../../../generators/common/imports');
 
 // TODO: emit definition (to a string) & also check snapshots based on that. It would allow checking both the structure & the output.
 describe('Attributes', () => {
   afterEach(() => {
-    jest.resetAllMocks();
+    jest.clearAllMocks();
   });
 
   describe('Attribute to Property Signature', () => {
@@ -48,7 +48,7 @@ describe('Attributes', () => {
 
       expect(prop.type.types).toHaveLength(1);
       expect(prop.type.types[0].kind).toBe(ts.SyntaxKind.TypeReference);
-      expect(prop.type.types[0].typeName.escapedText).toBe('StringAttribute');
+      expect(prop.type.types[0].typeName.escapedText).toBe('Attribute.String');
       expect(prop.type.types[0].typeArguments).toBeUndefined();
     });
 
@@ -60,7 +60,7 @@ describe('Attributes', () => {
 
       expect(prop.type.types).toHaveLength(1);
       expect(prop.type.types[0].kind).toBe(ts.SyntaxKind.TypeReference);
-      expect(prop.type.types[0].typeName.escapedText).toBe('ComponentAttribute');
+      expect(prop.type.types[0].typeName.escapedText).toBe('Attribute.Component');
       expect(prop.type.types[0].typeArguments).toHaveLength(1);
       expect(prop.type.types[0].typeArguments[0].kind).toBe(ts.SyntaxKind.StringLiteral);
       expect(prop.type.types[0].typeArguments[0].text).toBe('default.comp');
@@ -82,14 +82,14 @@ describe('Attributes', () => {
       const [attributeType, requiredOptionType] = prop.type.types;
 
       expect(attributeType.kind).toBe(ts.SyntaxKind.TypeReference);
-      expect(attributeType.typeName.escapedText).toBe('EnumerationAttribute');
+      expect(attributeType.typeName.escapedText).toBe('Attribute.Enumeration');
       expect(attributeType.typeArguments).toHaveLength(1);
       expect(attributeType.typeArguments[0].kind).toBe(ts.SyntaxKind.TupleType);
       expect(attributeType.typeArguments[0].elements[0].text).toBe('a');
       expect(attributeType.typeArguments[0].elements[1].text).toBe('b');
 
       expect(requiredOptionType.kind).toBe(ts.SyntaxKind.TypeReference);
-      expect(requiredOptionType.typeName.escapedText).toBe('DefaultTo');
+      expect(requiredOptionType.typeName.escapedText).toBe('Attribute.DefaultTo');
       expect(requiredOptionType.typeArguments).toHaveLength(1);
       expect(requiredOptionType.typeArguments[0].kind).toBe(ts.SyntaxKind.StringLiteral);
       expect(requiredOptionType.typeArguments[0].text).toBe('b');
@@ -108,22 +108,22 @@ describe('Attributes', () => {
     });
 
     test.each([
-      ['string', 'StringAttribute'],
-      ['text', 'TextAttribute'],
-      ['richtext', 'RichTextAttribute'],
-      ['password', 'PasswordAttribute'],
-      ['email', 'EmailAttribute'],
-      ['date', 'DateAttribute'],
-      ['time', 'TimeAttribute'],
-      ['datetime', 'DateTimeAttribute'],
-      ['timestamp', 'TimestampAttribute'],
-      ['integer', 'IntegerAttribute'],
-      ['biginteger', 'BigIntegerAttribute'],
-      ['float', 'FloatAttribute'],
-      ['decimal', 'DecimalAttribute'],
-      ['boolean', 'BooleanAttribute'],
-      ['json', 'JSONAttribute'],
-      ['media', 'MediaAttribute'],
+      ['string', 'Attribute.String'],
+      ['text', 'Attribute.Text'],
+      ['richtext', 'Attribute.RichText'],
+      ['password', 'Attribute.Password'],
+      ['email', 'Attribute.Email'],
+      ['date', 'Attribute.Date'],
+      ['time', 'Attribute.Time'],
+      ['datetime', 'Attribute.DateTime'],
+      ['timestamp', 'Attribute.Timestamp'],
+      ['integer', 'Attribute.Integer'],
+      ['biginteger', 'Attribute.BigInteger'],
+      ['float', 'Attribute.Float'],
+      ['decimal', 'Attribute.Decimal'],
+      ['boolean', 'Attribute.Boolean'],
+      ['json', 'Attribute.JSON'],
+      ['media', 'Attribute.Media'],
     ])('Basic %p attribute should map to a %p type', (type, expectedType) => {
       const typeNode = getAttributeType('foo', { type });
 
@@ -134,7 +134,7 @@ describe('Attributes', () => {
       expect(typeNode.typeArguments).toBeUndefined();
 
       expect(consoleWarnMock).not.toHaveBeenCalled();
-      expect(addImport).toHaveBeenCalledWith(expectedType);
+      expect(addImport).toHaveBeenCalledWith('Attribute');
     });
 
     describe('Complex types (with generic type parameters)', () => {
@@ -145,7 +145,7 @@ describe('Attributes', () => {
         expect(typeNode.typeName.escapedText).toBe(typeName);
 
         expect(consoleWarnMock).not.toHaveBeenCalled();
-        expect(addImport).toHaveBeenCalledWith(typeName);
+        expect(addImport).toHaveBeenCalledWith('Attribute');
       };
 
       describe('Enumeration', () => {
@@ -153,7 +153,7 @@ describe('Attributes', () => {
           const attribute = { type: 'enumeration', enum: ['a', 'b', 'c'] };
           const typeNode = getAttributeType('foo', attribute);
 
-          defaultAssertions(typeNode, 'EnumerationAttribute');
+          defaultAssertions(typeNode, 'Attribute.Enumeration');
 
           expect(typeNode.typeArguments).toHaveLength(1);
           expect(typeNode.typeArguments[0].kind).toBe(ts.SyntaxKind.TupleType);
@@ -174,7 +174,7 @@ describe('Attributes', () => {
           const attribute = { type: 'uid' };
           const typeNode = getAttributeType('foo', attribute);
 
-          defaultAssertions(typeNode, 'UIDAttribute');
+          defaultAssertions(typeNode, 'Attribute.UID');
 
           expect(typeNode.typeArguments).toBeUndefined();
         });
@@ -183,7 +183,7 @@ describe('Attributes', () => {
           const attribute = { type: 'uid', targetField: 'bar' };
           const typeNode = getAttributeType('foo', attribute, 'api::bar.bar');
 
-          defaultAssertions(typeNode, 'UIDAttribute');
+          defaultAssertions(typeNode, 'Attribute.UID');
 
           expect(typeNode.typeArguments).not.toBeUndefined();
           expect(typeNode.typeArguments).toHaveLength(2);
@@ -199,7 +199,7 @@ describe('Attributes', () => {
           const attribute = { type: 'uid', options: { separator: '_' } };
           const typeNode = getAttributeType('foo', attribute);
 
-          defaultAssertions(typeNode, 'UIDAttribute');
+          defaultAssertions(typeNode, 'Attribute.UID');
 
           expect(typeNode.typeArguments).toHaveLength(3);
 
@@ -224,7 +224,7 @@ describe('Attributes', () => {
           const attribute = { type: 'uid', options: { separator: '_' }, targetField: 'bar' };
           const typeNode = getAttributeType('foo', attribute, 'api::bar.bar');
 
-          defaultAssertions(typeNode, 'UIDAttribute');
+          defaultAssertions(typeNode, 'Attribute.UID');
 
           expect(typeNode.typeArguments).toHaveLength(3);
 
@@ -254,7 +254,7 @@ describe('Attributes', () => {
           const attribute = { type: 'relation', relation: 'oneToOne', target: 'api::bar.bar' };
           const typeNode = getAttributeType('foo', attribute, 'api::foo.foo');
 
-          defaultAssertions(typeNode, 'RelationAttribute');
+          defaultAssertions(typeNode, 'Attribute.Relation');
 
           expect(typeNode.typeArguments).toHaveLength(3);
 
@@ -272,7 +272,7 @@ describe('Attributes', () => {
           const attribute = { type: 'relation', relation: 'morphMany' };
           const typeNode = getAttributeType('foo', attribute, 'api::foo.foo');
 
-          defaultAssertions(typeNode, 'RelationAttribute');
+          defaultAssertions(typeNode, 'Attribute.Relation');
 
           expect(typeNode.typeArguments).toHaveLength(2);
 
@@ -289,7 +289,7 @@ describe('Attributes', () => {
           const attribute = { type: 'component', component: 'default.comp', repeatable: true };
           const typeNode = getAttributeType('foo', attribute);
 
-          defaultAssertions(typeNode, 'ComponentAttribute');
+          defaultAssertions(typeNode, 'Attribute.Component');
 
           expect(typeNode.typeArguments).toHaveLength(2);
 
@@ -303,7 +303,7 @@ describe('Attributes', () => {
           const attribute = { type: 'component', component: 'default.comp' };
           const typeNode = getAttributeType('foo', attribute);
 
-          defaultAssertions(typeNode, 'ComponentAttribute');
+          defaultAssertions(typeNode, 'Attribute.Component');
 
           expect(typeNode.typeArguments).toHaveLength(1);
 
@@ -317,7 +317,7 @@ describe('Attributes', () => {
           const attribute = { type: 'dynamiczone', components: ['default.comp1', 'default.comp2'] };
           const typeNode = getAttributeType('foo', attribute);
 
-          defaultAssertions(typeNode, 'DynamicZoneAttribute');
+          defaultAssertions(typeNode, 'Attribute.DynamicZone');
 
           expect(typeNode.typeArguments).toHaveLength(1);
 
@@ -359,7 +359,7 @@ describe('Attributes', () => {
 
           expect(modifiers).toHaveLength(1);
           expect(modifiers[0].kind).toBe(ts.SyntaxKind.TypeReference);
-          expect(modifiers[0].typeName.escapedText).toBe('RequiredAttribute');
+          expect(modifiers[0].typeName.escapedText).toBe('Attribute.Required');
         });
       });
 
@@ -384,7 +384,7 @@ describe('Attributes', () => {
 
           expect(modifiers).toHaveLength(1);
           expect(modifiers[0].kind).toBe(ts.SyntaxKind.TypeReference);
-          expect(modifiers[0].typeName.escapedText).toBe('PrivateAttribute');
+          expect(modifiers[0].typeName.escapedText).toBe('Attribute.Private');
         });
       });
 
@@ -409,7 +409,7 @@ describe('Attributes', () => {
 
           expect(modifiers).toHaveLength(1);
           expect(modifiers[0].kind).toBe(ts.SyntaxKind.TypeReference);
-          expect(modifiers[0].typeName.escapedText).toBe('UniqueAttribute');
+          expect(modifiers[0].typeName.escapedText).toBe('Attribute.Unique');
         });
       });
 
@@ -434,7 +434,7 @@ describe('Attributes', () => {
 
           expect(modifiers).toHaveLength(1);
           expect(modifiers[0].kind).toBe(ts.SyntaxKind.TypeReference);
-          expect(modifiers[0].typeName.escapedText).toBe('ConfigurableAttribute');
+          expect(modifiers[0].typeName.escapedText).toBe('Attribute.Configurable');
         });
       });
 
@@ -455,7 +455,7 @@ describe('Attributes', () => {
 
           expect(modifiers).toHaveLength(1);
           expect(modifiers[0].kind).toBe(ts.SyntaxKind.TypeReference);
-          expect(modifiers[0].typeName.escapedText).toBe('CustomField');
+          expect(modifiers[0].typeName.escapedText).toBe('Attribute.CustomField');
           expect(modifiers[0].typeArguments).toHaveLength(1);
           expect(modifiers[0].typeArguments[0].kind).toBe(ts.SyntaxKind.StringLiteral);
           expect(modifiers[0].typeArguments[0].text).toBe('plugin::color-picker.color');
@@ -473,7 +473,7 @@ describe('Attributes', () => {
 
           expect(modifiers).toHaveLength(1);
           expect(modifiers[0].kind).toBe(ts.SyntaxKind.TypeReference);
-          expect(modifiers[0].typeName.escapedText).toBe('CustomField');
+          expect(modifiers[0].typeName.escapedText).toBe('Attribute.CustomField');
           expect(modifiers[0].typeArguments).toHaveLength(2);
           expect(modifiers[0].typeArguments[0].kind).toBe(ts.SyntaxKind.StringLiteral);
           expect(modifiers[0].typeArguments[0].text).toBe('plugin::color-picker.color');
@@ -507,7 +507,7 @@ describe('Attributes', () => {
 
           expect(modifiers).toHaveLength(1);
           expect(modifiers[0].kind).toBe(ts.SyntaxKind.TypeReference);
-          expect(modifiers[0].typeName.escapedText).toBe('SetPluginOptions');
+          expect(modifiers[0].typeName.escapedText).toBe('Attribute.SetPluginOptions');
           expect(modifiers[0].typeArguments).toHaveLength(1);
           expect(modifiers[0].typeArguments[0].kind).toBe(ts.SyntaxKind.TypeLiteral);
           expect(modifiers[0].typeArguments[0].members).toHaveLength(1);
@@ -546,21 +546,29 @@ describe('Attributes', () => {
           expect(modifiers).toHaveLength(1);
 
           expect(modifiers[0].kind).toBe(ts.SyntaxKind.TypeReference);
-          expect(modifiers[0].typeName.escapedText).toBe('SetMinMax');
+          expect(modifiers[0].typeName.escapedText).toBe('Attribute.SetMinMax');
 
-          expect(modifiers[0].typeArguments).toHaveLength(1);
-          expect(modifiers[0].typeArguments[0].kind).toBe(ts.SyntaxKind.TypeLiteral);
-          expect(modifiers[0].typeArguments[0].members).toHaveLength(1);
+          const [setMinMax] = modifiers;
+          const { typeArguments } = setMinMax;
+
+          expect(typeArguments).toBeDefined();
+          expect(typeArguments).toHaveLength(2);
+
+          const [definition, typeofMinMax] = typeArguments;
 
           // Min
-          expect(modifiers[0].typeArguments[0].members[0].kind).toBe(
-            ts.SyntaxKind.PropertyDeclaration
-          );
-          expect(modifiers[0].typeArguments[0].members[0].name.escapedText).toBe('min');
-          expect(modifiers[0].typeArguments[0].members[0].type.kind).toBe(
-            ts.SyntaxKind.NumericLiteral
-          );
-          expect(modifiers[0].typeArguments[0].members[0].type.text).toBe('2');
+          expect(definition.kind).toBe(ts.SyntaxKind.TypeLiteral);
+          expect(definition.members).toHaveLength(1);
+
+          const [min] = definition.members;
+
+          expect(min.kind).toBe(ts.SyntaxKind.PropertyDeclaration);
+          expect(min.name.escapedText).toBe('min');
+          expect(min.type.kind).toBe(ts.SyntaxKind.NumericLiteral);
+          expect(min.type.text).toBe('2');
+
+          // Check for number keyword on the second typeArgument
+          expect(typeofMinMax.kind).toBe(ts.SyntaxKind.NumberKeyword);
         });
 
         test('No Min, Max: 3', () => {
@@ -570,21 +578,29 @@ describe('Attributes', () => {
           expect(modifiers).toHaveLength(1);
 
           expect(modifiers[0].kind).toBe(ts.SyntaxKind.TypeReference);
-          expect(modifiers[0].typeName.escapedText).toBe('SetMinMax');
+          expect(modifiers[0].typeName.escapedText).toBe('Attribute.SetMinMax');
 
-          expect(modifiers[0].typeArguments).toHaveLength(1);
-          expect(modifiers[0].typeArguments[0].kind).toBe(ts.SyntaxKind.TypeLiteral);
-          expect(modifiers[0].typeArguments[0].members).toHaveLength(1);
+          const [setMinMax] = modifiers;
+          const { typeArguments } = setMinMax;
 
-          // Min
-          expect(modifiers[0].typeArguments[0].members[0].kind).toBe(
-            ts.SyntaxKind.PropertyDeclaration
-          );
-          expect(modifiers[0].typeArguments[0].members[0].name.escapedText).toBe('max');
-          expect(modifiers[0].typeArguments[0].members[0].type.kind).toBe(
-            ts.SyntaxKind.NumericLiteral
-          );
-          expect(modifiers[0].typeArguments[0].members[0].type.text).toBe('3');
+          expect(typeArguments).toBeDefined();
+          expect(typeArguments).toHaveLength(2);
+
+          const [definition, typeofMinMax] = typeArguments;
+
+          // Max
+          expect(definition.kind).toBe(ts.SyntaxKind.TypeLiteral);
+          expect(definition.members).toHaveLength(1);
+
+          const [max] = definition.members;
+
+          expect(max.kind).toBe(ts.SyntaxKind.PropertyDeclaration);
+          expect(max.name.escapedText).toBe('max');
+          expect(max.type.kind).toBe(ts.SyntaxKind.NumericLiteral);
+          expect(max.type.text).toBe('3');
+
+          // Check for number keyword on the second typeArgument
+          expect(typeofMinMax.kind).toBe(ts.SyntaxKind.NumberKeyword);
         });
 
         test('Min: 4, Max: 12', () => {
@@ -594,30 +610,66 @@ describe('Attributes', () => {
           expect(modifiers).toHaveLength(1);
 
           expect(modifiers[0].kind).toBe(ts.SyntaxKind.TypeReference);
-          expect(modifiers[0].typeName.escapedText).toBe('SetMinMax');
+          expect(modifiers[0].typeName.escapedText).toBe('Attribute.SetMinMax');
 
-          expect(modifiers[0].typeArguments).toHaveLength(1);
-          expect(modifiers[0].typeArguments[0].kind).toBe(ts.SyntaxKind.TypeLiteral);
-          expect(modifiers[0].typeArguments[0].members).toHaveLength(2);
+          const [setMinMax] = modifiers;
+          const { typeArguments } = setMinMax;
 
-          // Min
-          expect(modifiers[0].typeArguments[0].members[0].kind).toBe(
-            ts.SyntaxKind.PropertyDeclaration
-          );
-          expect(modifiers[0].typeArguments[0].members[0].name.escapedText).toBe('min');
-          expect(modifiers[0].typeArguments[0].members[0].type.kind).toBe(
-            ts.SyntaxKind.NumericLiteral
-          );
-          expect(modifiers[0].typeArguments[0].members[0].type.text).toBe('4');
+          expect(typeArguments).toBeDefined();
+          expect(typeArguments).toHaveLength(2);
 
-          expect(modifiers[0].typeArguments[0].members[1].kind).toBe(
-            ts.SyntaxKind.PropertyDeclaration
-          );
-          expect(modifiers[0].typeArguments[0].members[1].name.escapedText).toBe('max');
-          expect(modifiers[0].typeArguments[0].members[1].type.kind).toBe(
-            ts.SyntaxKind.NumericLiteral
-          );
-          expect(modifiers[0].typeArguments[0].members[1].type.text).toBe('12');
+          const [definition, typeofMinMax] = typeArguments;
+
+          // Min/Max
+          expect(definition.kind).toBe(ts.SyntaxKind.TypeLiteral);
+          expect(definition.members).toHaveLength(2);
+
+          const [min, max] = definition.members;
+
+          expect(min.kind).toBe(ts.SyntaxKind.PropertyDeclaration);
+          expect(min.name.escapedText).toBe('min');
+          expect(min.type.kind).toBe(ts.SyntaxKind.NumericLiteral);
+          expect(min.type.text).toBe('4');
+
+          expect(max.kind).toBe(ts.SyntaxKind.PropertyDeclaration);
+          expect(max.name.escapedText).toBe('max');
+          expect(max.type.kind).toBe(ts.SyntaxKind.NumericLiteral);
+          expect(max.type.text).toBe('12');
+
+          // Check for number keyword on the second typeArgument
+          expect(typeofMinMax.kind).toBe(ts.SyntaxKind.NumberKeyword);
+        });
+
+        test('Min: "1"', () => {
+          const attribute = { min: '1' };
+          const modifiers = getAttributeModifiers(attribute);
+
+          expect(modifiers).toHaveLength(1);
+
+          expect(modifiers[0].kind).toBe(ts.SyntaxKind.TypeReference);
+          expect(modifiers[0].typeName.escapedText).toBe('Attribute.SetMinMax');
+
+          const [setMinMax] = modifiers;
+          const { typeArguments } = setMinMax;
+
+          expect(typeArguments).toBeDefined();
+          expect(typeArguments).toHaveLength(2);
+
+          const [definition, typeofMinMax] = typeArguments;
+
+          // Min/Max
+          expect(definition.kind).toBe(ts.SyntaxKind.TypeLiteral);
+          expect(definition.members).toHaveLength(1);
+
+          const [min] = definition.members;
+
+          expect(min.kind).toBe(ts.SyntaxKind.PropertyDeclaration);
+          expect(min.name.escapedText).toBe('min');
+          expect(min.type.kind).toBe(ts.SyntaxKind.StringLiteral);
+          expect(min.type.text).toBe('1');
+
+          // Check for string keyword on the second typeArgument
+          expect(typeofMinMax.kind).toBe(ts.SyntaxKind.StringKeyword);
         });
       });
 
@@ -636,7 +688,7 @@ describe('Attributes', () => {
           expect(modifiers).toHaveLength(1);
 
           expect(modifiers[0].kind).toBe(ts.SyntaxKind.TypeReference);
-          expect(modifiers[0].typeName.escapedText).toBe('SetMinMaxLength');
+          expect(modifiers[0].typeName.escapedText).toBe('Attribute.SetMinMaxLength');
 
           expect(modifiers[0].typeArguments).toHaveLength(1);
           expect(modifiers[0].typeArguments[0].kind).toBe(ts.SyntaxKind.TypeLiteral);
@@ -660,7 +712,7 @@ describe('Attributes', () => {
           expect(modifiers).toHaveLength(1);
 
           expect(modifiers[0].kind).toBe(ts.SyntaxKind.TypeReference);
-          expect(modifiers[0].typeName.escapedText).toBe('SetMinMaxLength');
+          expect(modifiers[0].typeName.escapedText).toBe('Attribute.SetMinMaxLength');
 
           expect(modifiers[0].typeArguments).toHaveLength(1);
           expect(modifiers[0].typeArguments[0].kind).toBe(ts.SyntaxKind.TypeLiteral);
@@ -684,7 +736,7 @@ describe('Attributes', () => {
           expect(modifiers).toHaveLength(1);
 
           expect(modifiers[0].kind).toBe(ts.SyntaxKind.TypeReference);
-          expect(modifiers[0].typeName.escapedText).toBe('SetMinMaxLength');
+          expect(modifiers[0].typeName.escapedText).toBe('Attribute.SetMinMaxLength');
 
           expect(modifiers[0].typeArguments).toHaveLength(1);
           expect(modifiers[0].typeArguments[0].kind).toBe(ts.SyntaxKind.TypeLiteral);
@@ -726,7 +778,7 @@ describe('Attributes', () => {
           expect(modifiers).toHaveLength(1);
 
           expect(modifiers[0].kind).toBe(ts.SyntaxKind.TypeReference);
-          expect(modifiers[0].typeName.escapedText).toBe('DefaultTo');
+          expect(modifiers[0].typeName.escapedText).toBe('Attribute.DefaultTo');
 
           expect(modifiers[0].typeArguments).toHaveLength(1);
           expect(modifiers[0].typeArguments[0].kind).toBe(ts.SyntaxKind.TrueKeyword);
@@ -739,7 +791,7 @@ describe('Attributes', () => {
           expect(modifiers).toHaveLength(1);
 
           expect(modifiers[0].kind).toBe(ts.SyntaxKind.TypeReference);
-          expect(modifiers[0].typeName.escapedText).toBe('DefaultTo');
+          expect(modifiers[0].typeName.escapedText).toBe('Attribute.DefaultTo');
 
           expect(modifiers[0].typeArguments).toHaveLength(1);
           expect(modifiers[0].typeArguments[0].kind).toBe(ts.SyntaxKind.TypeLiteral);

package/lib/__tests__/generators/schemas/imports.test.js

@@ -6,7 +6,7 @@ const {
   addImport,
   generateImportDefinition,
   getImports,
-} = require('../../../generators/schemas/imports');
+} = require('../../../generators/common/imports');
 
 describe('Imports', () => {
   test('When first loaded, the list of imports should be empty', () => {
@@ -27,28 +27,30 @@ describe('Imports', () => {
   });
 
   test('Generate an import type definition containing the registered import', () => {
-    const def = generateImportDefinition();
+    const defs = generateImportDefinition();
 
-    expect(def.kind).toBe(ts.SyntaxKind.ImportDeclaration);
+    defs.forEach((def) => {
+      expect(def.kind).toBe(ts.SyntaxKind.ImportDeclaration);
 
-    // Module specifier
-    expect(def.moduleSpecifier.kind).toBe(ts.SyntaxKind.StringLiteral);
-    expect(def.moduleSpecifier.text).toBe('@strapi/strapi');
+      // Module specifier
+      expect(def.moduleSpecifier.kind).toBe(ts.SyntaxKind.StringLiteral);
+      expect(def.moduleSpecifier.text).toBe('@strapi/strapi');
 
-    // Import clause (should be named imports)
-    expect(def.importClause.kind).toBe(ts.SyntaxKind.ImportClause);
+      // Import clause (should be named imports)
+      expect(def.importClause.kind).toBe(ts.SyntaxKind.ImportClause);
 
-    const { elements } = def.importClause.namedBindings;
+      const { elements } = def.importClause.namedBindings;
 
-    expect(elements).toHaveLength(2);
+      expect(elements).toHaveLength(2);
 
-    // Import clauses
-    getImports().forEach((namedImport, index) => {
-      const element = elements[index];
+      // Import clauses
+      getImports().forEach((namedImport, index) => {
+        const element = elements[index];
 
-      expect(element.kind).toBe(ts.SyntaxKind.ImportSpecifier);
-      expect(element.name.kind).toBe(ts.SyntaxKind.Identifier);
-      expect(element.name.escapedText).toBe(namedImport);
+        expect(element.kind).toBe(ts.SyntaxKind.ImportSpecifier);
+        expect(element.name.kind).toBe(ts.SyntaxKind.Identifier);
+        expect(element.name.escapedText).toBe(namedImport);
+      });
     });
   });
 });

package/lib/__tests__/generators/schemas/utils.test.js

@@ -4,71 +4,18 @@ const ts = require('typescript');
 const { factory } = require('typescript');
 
 const {
-  getAllStrapiSchemas,
   getDefinitionAttributesCount,
   getSchemaExtendsTypeName,
   getSchemaInterfaceName,
   getSchemaModelType,
   getTypeNode,
   toTypeLiteral,
-} = require('../../../generators/schemas/utils');
+} = require('../../../generators/common/models/utils');
 
 describe('Utils', () => {
-  describe('Get All Strapi Schemas', () => {
-    test('Get both components and content types', () => {
-      const strapi = {
-        contentTypes: {
-          ctA: {},
-          ctB: {},
-        },
-        components: {
-          comp1: {},
-          comp2: {},
-          comp3: {},
-        },
-      };
-
-      const schemas = getAllStrapiSchemas(strapi);
-
-      expect(schemas).toMatchObject({ ctA: {}, ctB: {}, comp1: {}, comp2: {}, comp3: {} });
-    });
-
-    test('Get only components if there is no content type', () => {
-      const strapi = {
-        contentTypes: {},
-
-        components: {
-          comp1: {},
-          comp2: {},
-          comp3: {},
-        },
-      };
-
-      const schemas = getAllStrapiSchemas(strapi);
-
-      expect(schemas).toMatchObject({ comp1: {}, comp2: {}, comp3: {} });
-    });
-
-    test('Get only content types if there is no component', () => {
-      const strapi = {
-        contentTypes: {
-          ctA: {},
-          ctB: {},
-        },
-
-        components: {},
-      };
-
-      const schemas = getAllStrapiSchemas(strapi);
-
-      expect(schemas).toMatchObject({ ctA: {}, ctB: {} });
-    });
-  });
-
   describe('Get Definition Attributes Count', () => {
     const createMainNode = (members = []) => {
       return factory.createInterfaceDeclaration(
-        undefined,
         undefined,
         factory.createIdentifier('Foo'),
         undefined,
@@ -79,7 +26,6 @@ describe('Utils', () => {
 
     const createPropertyDeclaration = (name, type) => {
       return factory.createPropertyDeclaration(
-        undefined,
         undefined,
         factory.createIdentifier(name),
         undefined,
@@ -174,10 +120,10 @@ describe('Utils', () => {
 
   describe('Get Schema Extends Type Name', () => {
     test.each([
-      [{ modelType: 'component', kind: null }, 'ComponentSchema'],
-      [{ modelType: 'contentType', kind: 'singleType' }, 'SingleTypeSchema'],
-      [{ modelType: 'contentType', kind: 'collectionType' }, 'CollectionTypeSchema'],
-      [{ modelType: 'invalidType', kind: 'foo' }, 'Schema'],
+      [{ modelType: 'component', kind: null }, 'Schema.Component'],
+      [{ modelType: 'contentType', kind: 'singleType' }, 'Schema.SingleType'],
+      [{ modelType: 'contentType', kind: 'collectionType' }, 'Schema.CollectionType'],
+      [{ modelType: 'invalidType', kind: 'foo' }, null],
     ])("Expect %p to generate %p as the base type for a schema's interface", (schema, expected) => {
       expect(getSchemaExtendsTypeName(schema)).toBe(expected);
     });