@strapi/typescript-utils 0.0.0-next.e9bb5ccdc459f4c6b6717a2d5d86359b7a47d47d → 0.0.0-next.f7babb775ed9a7e18d8351cb7f74c63e016323c4

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,7 +546,7 @@ 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);
@@ -570,7 +570,7 @@ 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);
@@ -594,7 +594,7 @@ 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);
@@ -636,7 +636,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 +660,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 +684,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 +726,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 +739,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,67 +4,15 @@ 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(
@@ -172,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);
     });

package/lib/generators/{schemas → common}/imports.js

@@ -22,11 +22,13 @@ module.exports = {
       factory.createImportSpecifier(false, undefined, factory.createIdentifier(key))
     );
 
-    return factory.createImportDeclaration(
-      undefined,
-      factory.createImportClause(false, undefined, factory.createNamedImports(formattedImports)),
-      factory.createStringLiteral('@strapi/strapi'),
-      undefined
-    );
+    return [
+      factory.createImportDeclaration(
+        undefined,
+        factory.createImportClause(true, undefined, factory.createNamedImports(formattedImports)),
+        factory.createStringLiteral('@strapi/strapi'),
+        undefined
+      ),
+    ];
   },
 };

package/lib/generators/common/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const models = require('./models');
+const imports = require('./imports');
+
+module.exports = {
+  models,
+  imports,
+};

package/lib/generators/{schemas → common/models}/attributes.js

@@ -3,8 +3,8 @@
 const { factory } = require('typescript');
 const _ = require('lodash/fp');
 
-const { addImport } = require('./imports');
-const { getTypeNode, toTypeLiteral } = require('./utils');
+const { addImport } = require('../imports');
+const { getTypeNode, toTypeLiteral, withAttributeNamespace, NAMESPACES } = require('./utils');
 const mappers = require('./mappers');
 
 /**
@@ -26,7 +26,8 @@ const getAttributeType = (attributeName, attribute, uid) => {
 
   const [attributeType, typeParams] = mappers[attribute.type]({ uid, attribute, attributeName });
 
-  addImport(attributeType);
+  // Make sure the attribute namespace is imported
+  addImport(NAMESPACES.attribute);
 
   return getTypeNode(attributeType, typeParams);
 };
@@ -42,38 +43,36 @@ const getAttributeModifiers = (attribute) => {
 
   // Required
   if (attribute.required) {
-    addImport('RequiredAttribute');
-
-    modifiers.push(factory.createTypeReferenceNode(factory.createIdentifier('RequiredAttribute')));
+    modifiers.push(
+      factory.createTypeReferenceNode(factory.createIdentifier(withAttributeNamespace('Required')))
+    );
   }
 
   // Private
   if (attribute.private) {
-    addImport('PrivateAttribute');
-
-    modifiers.push(factory.createTypeReferenceNode(factory.createIdentifier('PrivateAttribute')));
+    modifiers.push(
+      factory.createTypeReferenceNode(factory.createIdentifier(withAttributeNamespace('Private')))
+    );
   }
 
   // Unique
   if (attribute.unique) {
-    addImport('UniqueAttribute');
-
-    modifiers.push(factory.createTypeReferenceNode(factory.createIdentifier('UniqueAttribute')));
+    modifiers.push(
+      factory.createTypeReferenceNode(factory.createIdentifier(withAttributeNamespace('Unique')))
+    );
   }
 
   // Configurable
   if (attribute.configurable) {
-    addImport('ConfigurableAttribute');
-
     modifiers.push(
-      factory.createTypeReferenceNode(factory.createIdentifier('ConfigurableAttribute'))
+      factory.createTypeReferenceNode(
+        factory.createIdentifier(withAttributeNamespace('Configurable'))
+      )
     );
   }
 
   // Custom field
   if (attribute.customField) {
-    addImport('CustomField');
-
     const customFieldUid = factory.createStringLiteral(attribute.customField);
     const typeArguments = [customFieldUid];
 
@@ -82,17 +81,18 @@ const getAttributeModifiers = (attribute) => {
     }
 
     modifiers.push(
-      factory.createTypeReferenceNode(factory.createIdentifier('CustomField'), typeArguments)
+      factory.createTypeReferenceNode(
+        factory.createIdentifier(withAttributeNamespace('CustomField')),
+        typeArguments
+      )
     );
   }
 
   // Plugin Options
   if (!_.isEmpty(attribute.pluginOptions)) {
-    addImport('SetPluginOptions');
-
     modifiers.push(
       factory.createTypeReferenceNode(
-        factory.createIdentifier('SetPluginOptions'),
+        factory.createIdentifier(withAttributeNamespace('SetPluginOptions')),
         // Transform the pluginOptions object into an object literal expression
         [toTypeLiteral(attribute.pluginOptions)]
       )
@@ -102,38 +102,37 @@ const getAttributeModifiers = (attribute) => {
   // Min / Max
   // TODO: Always provide a second type argument for min/max (ie: resolve the attribute scalar type with a `GetAttributeType<${mappers[attribute][0]}>` (useful for biginter (string values)))
   if (!_.isNil(attribute.min) || !_.isNil(attribute.max)) {
-    addImport('SetMinMax');
-
     const minMaxProperties = _.pick(['min', 'max'], attribute);
 
     modifiers.push(
-      factory.createTypeReferenceNode(factory.createIdentifier('SetMinMax'), [
-        toTypeLiteral(minMaxProperties),
-      ])
+      factory.createTypeReferenceNode(
+        factory.createIdentifier(withAttributeNamespace('SetMinMax')),
+        [toTypeLiteral(minMaxProperties)]
+      )
     );
   }
 
   // Min length / Max length
   if (!_.isNil(attribute.minLength) || !_.isNil(attribute.maxLength)) {
-    addImport('SetMinMaxLength');
-
     const minMaxProperties = _.pick(['minLength', 'maxLength'], attribute);
 
     modifiers.push(
-      factory.createTypeReferenceNode(factory.createIdentifier('SetMinMaxLength'), [
-        toTypeLiteral(minMaxProperties),
-      ])
+      factory.createTypeReferenceNode(
+        factory.createIdentifier(withAttributeNamespace('SetMinMaxLength')),
+        [toTypeLiteral(minMaxProperties)]
+      )
     );
   }
 
   // Default
   if (!_.isNil(attribute.default)) {
-    addImport('DefaultTo');
-
     const defaultLiteral = toTypeLiteral(attribute.default);
 
     modifiers.push(
-      factory.createTypeReferenceNode(factory.createIdentifier('DefaultTo'), [defaultLiteral])
+      factory.createTypeReferenceNode(
+        factory.createIdentifier(withAttributeNamespace('DefaultTo')),
+        [defaultLiteral]
+      )
     );
   }
 

package/lib/generators/common/models/index.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const schema = require('./schema');
+const attributes = require('./attributes');
+const mappers = require('./mappers');
+const utils = require('./utils');
+const imports = require('../imports');
+
+module.exports = {
+  schema,
+  attributes,
+  mappers,
+  utils,
+  imports,
+};