@strapi/typescript-utils 4.3.0-beta.2 → 4.3.2-alpha.0

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

@@ -6,21 +6,97 @@ const consoleWarnMock = jest.spyOn(console, 'warn').mockImplementation();
 
 const ts = require('typescript');
 
-const { getAttributeType } = require('../../../generators/schemas/attributes');
+const attributeToPropertySignature = require('../../../generators/schemas/attributes');
+const {
+  getAttributeType,
+  getAttributeModifiers,
+} = require('../../../generators/schemas/attributes');
 const { addImport } = require('../../../generators/schemas/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();
   });
 
-  // TODO
-  // describe('Attribute to Property Signature', () => {});
+  describe('Attribute to Property Signature', () => {
+    const schema = { uid: 'api::foo.foo' };
+    const attributeName = 'foo';
 
-  // TODO
-  // describe('Mappers', () => {});
+    const toPropertySignature = attribute => {
+      return attributeToPropertySignature(schema, attributeName, attribute);
+    };
 
-  describe('Get Attribute Type', () => {
+    const defaultAssertion = node => {
+      expect(node.kind).toBe(ts.SyntaxKind.PropertySignature);
+      expect(node.name.escapedText).toBe(attributeName);
+      expect(node.type.kind).toBe(ts.SyntaxKind.IntersectionType);
+    };
+
+    test('Invalid attribute type', () => {
+      const attribute = { type: 'invalid' };
+      const prop = toPropertySignature(attribute);
+
+      expect(prop).toBeNull();
+    });
+
+    test('Attribute without type argument', () => {
+      const attribute = { type: 'string' };
+      const prop = toPropertySignature(attribute);
+
+      defaultAssertion(prop);
+
+      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].typeArguments).toBeUndefined();
+    });
+
+    test('Attribute with type argument', () => {
+      const attribute = { type: 'component', component: 'default.comp' };
+      const prop = toPropertySignature(attribute);
+
+      defaultAssertion(prop);
+
+      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].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');
+    });
+
+    test('Attribute with type argument and options', () => {
+      const attribute = {
+        type: 'enumeration',
+        enum: ['a', 'b'],
+        default: 'b',
+        configurable: false,
+      };
+      const prop = toPropertySignature(attribute);
+
+      defaultAssertion(prop);
+
+      expect(prop.type.types).toHaveLength(2);
+
+      const [attributeType, requiredOptionType] = prop.type.types;
+
+      expect(attributeType.kind).toBe(ts.SyntaxKind.TypeReference);
+      expect(attributeType.typeName.escapedText).toBe('EnumerationAttribute');
+      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.typeArguments).toHaveLength(1);
+      expect(requiredOptionType.typeArguments[0].kind).toBe(ts.SyntaxKind.StringLiteral);
+      expect(requiredOptionType.typeArguments[0].text).toBe('b');
+    });
+  });
+
+  describe('Get Attribute Type / Mappers', () => {
     test('If the attribute type is not valid then log an error and exit early without importing the type', () => {
       const typeNode = getAttributeType('foo', { type: 'invalid', uid: 'api::foo.foo' });
 
@@ -31,17 +107,34 @@ describe('Attributes', () => {
       expect(addImport).not.toHaveBeenCalled();
     });
 
-    test('Return a basic type node without generic type parameter', () => {
-      const typeNode = getAttributeType('foo', { type: 'string' });
+    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'],
+    ])('Basic %p attribute should map to a %p type', (type, expectedType) => {
+      const typeNode = getAttributeType('foo', { type });
 
       expect(ts.isTypeNode(typeNode)).toBeTruthy();
 
       expect(typeNode.kind).toBe(ts.SyntaxKind.TypeReference);
-      expect(typeNode.typeName.escapedText).toBe('StringAttribute');
+      expect(typeNode.typeName.escapedText).toBe(expectedType);
       expect(typeNode.typeArguments).toBeUndefined();
 
       expect(consoleWarnMock).not.toHaveBeenCalled();
-      expect(addImport).toHaveBeenCalledWith('StringAttribute');
+      expect(addImport).toHaveBeenCalledWith(expectedType);
     });
 
     describe('Complex types (with generic type parameters)', () => {
@@ -55,27 +148,556 @@ describe('Attributes', () => {
         expect(addImport).toHaveBeenCalledWith(typeName);
       };
 
-      test('Enumeration', () => {
-        const attribute = { type: 'enumeration', enum: ['a', 'b', 'c'] };
-        const typeNode = getAttributeType('foo', attribute);
+      describe('Enumeration', () => {
+        test('Enumeration with an enum property', () => {
+          const attribute = { type: 'enumeration', enum: ['a', 'b', 'c'] };
+          const typeNode = getAttributeType('foo', attribute);
+
+          defaultAssertions(typeNode, 'EnumerationAttribute');
+
+          expect(typeNode.typeArguments).toHaveLength(1);
+          expect(typeNode.typeArguments[0].kind).toBe(ts.SyntaxKind.TupleType);
+
+          const tupleElements = typeNode.typeArguments[0].elements;
+
+          attribute.enum.forEach((value, index) => {
+            const element = tupleElements[index];
+
+            expect(element.kind).toBe(ts.SyntaxKind.StringLiteral);
+            expect(element.text).toBe(value);
+          });
+        });
+      });
+
+      describe('UID', () => {
+        test('UID with no options and no target field', () => {
+          const attribute = { type: 'uid' };
+          const typeNode = getAttributeType('foo', attribute);
+
+          defaultAssertions(typeNode, 'UIDAttribute');
+
+          expect(typeNode.typeArguments).toBeUndefined();
+        });
+
+        test('UID with a target field and no options', () => {
+          const attribute = { type: 'uid', targetField: 'bar' };
+          const typeNode = getAttributeType('foo', attribute, 'api::bar.bar');
+
+          defaultAssertions(typeNode, 'UIDAttribute');
+
+          expect(typeNode.typeArguments).not.toBeUndefined();
+          expect(typeNode.typeArguments).toHaveLength(2);
+
+          expect(typeNode.typeArguments[0].kind).toBe(ts.SyntaxKind.StringLiteral);
+          expect(typeNode.typeArguments[0].text).toBe('api::bar.bar');
+
+          expect(typeNode.typeArguments[1].kind).toBe(ts.SyntaxKind.StringLiteral);
+          expect(typeNode.typeArguments[1].text).toBe('bar');
+        });
+
+        test('UID with partial options and no target field', () => {
+          const attribute = { type: 'uid', options: { separator: '_' } };
+          const typeNode = getAttributeType('foo', attribute);
+
+          defaultAssertions(typeNode, 'UIDAttribute');
+
+          expect(typeNode.typeArguments).toHaveLength(3);
+
+          expect(typeNode.typeArguments[0].kind).toBe(ts.SyntaxKind.UndefinedKeyword);
+          expect(typeNode.typeArguments[1].kind).toBe(ts.SyntaxKind.UndefinedKeyword);
+
+          const optionsLiteralNode = typeNode.typeArguments[2];
+
+          expect(optionsLiteralNode.kind).toBe(ts.SyntaxKind.TypeLiteral);
+          expect(optionsLiteralNode.members).toHaveLength(1);
+
+          expect(optionsLiteralNode.members[0].kind).toBe(ts.SyntaxKind.PropertyDeclaration);
+
+          expect(optionsLiteralNode.members[0].name.kind).toBe(ts.SyntaxKind.Identifier);
+          expect(optionsLiteralNode.members[0].name.escapedText).toBe('separator');
+
+          expect(optionsLiteralNode.members[0].type.kind).toBe(ts.SyntaxKind.StringLiteral);
+          expect(optionsLiteralNode.members[0].type.text).toBe('_');
+        });
+
+        test('UID with options and a target field', () => {
+          const attribute = { type: 'uid', options: { separator: '_' }, targetField: 'bar' };
+          const typeNode = getAttributeType('foo', attribute, 'api::bar.bar');
 
-        defaultAssertions(typeNode, 'EnumerationAttribute');
+          defaultAssertions(typeNode, 'UIDAttribute');
 
-        expect(typeNode.typeArguments).toHaveLength(1);
-        expect(typeNode.typeArguments[0].kind).toBe(ts.SyntaxKind.TupleType);
+          expect(typeNode.typeArguments).toHaveLength(3);
 
-        const tupleElements = typeNode.typeArguments[0].elements;
+          expect(typeNode.typeArguments[0].kind).toBe(ts.SyntaxKind.StringLiteral);
+          expect(typeNode.typeArguments[0].text).toBe('api::bar.bar');
 
-        attribute.enum.forEach((value, index) => {
-          const element = tupleElements[index];
+          expect(typeNode.typeArguments[1].kind).toBe(ts.SyntaxKind.StringLiteral);
+          expect(typeNode.typeArguments[1].text).toBe('bar');
 
-          expect(element.kind).toBe(ts.SyntaxKind.StringLiteral);
-          expect(element.text).toBe(value);
+          const optionsLiteralNode = typeNode.typeArguments[2];
+
+          expect(optionsLiteralNode.kind).toBe(ts.SyntaxKind.TypeLiteral);
+          expect(optionsLiteralNode.members).toHaveLength(1);
+
+          expect(optionsLiteralNode.members[0].kind).toBe(ts.SyntaxKind.PropertyDeclaration);
+
+          expect(optionsLiteralNode.members[0].name.kind).toBe(ts.SyntaxKind.Identifier);
+          expect(optionsLiteralNode.members[0].name.escapedText).toBe('separator');
+
+          expect(optionsLiteralNode.members[0].type.kind).toBe(ts.SyntaxKind.StringLiteral);
+          expect(optionsLiteralNode.members[0].type.text).toBe('_');
+        });
+      });
+
+      describe('Relation', () => {
+        test('Basic relation', () => {
+          const attribute = { type: 'relation', relation: 'oneToOne', target: 'api::bar.bar' };
+          const typeNode = getAttributeType('foo', attribute, 'api::foo.foo');
+
+          defaultAssertions(typeNode, 'RelationAttribute');
+
+          expect(typeNode.typeArguments).toHaveLength(3);
+
+          expect(typeNode.typeArguments[0].kind).toBe(ts.SyntaxKind.StringLiteral);
+          expect(typeNode.typeArguments[0].text).toBe('api::foo.foo');
+
+          expect(typeNode.typeArguments[1].kind).toBe(ts.SyntaxKind.StringLiteral);
+          expect(typeNode.typeArguments[1].text).toBe('oneToOne');
+
+          expect(typeNode.typeArguments[2].kind).toBe(ts.SyntaxKind.StringLiteral);
+          expect(typeNode.typeArguments[2].text).toBe('api::bar.bar');
+        });
+
+        test('Polymorphic relation', () => {
+          const attribute = { type: 'relation', relation: 'morphMany' };
+          const typeNode = getAttributeType('foo', attribute, 'api::foo.foo');
+
+          defaultAssertions(typeNode, 'RelationAttribute');
+
+          expect(typeNode.typeArguments).toHaveLength(2);
+
+          expect(typeNode.typeArguments[0].kind).toBe(ts.SyntaxKind.StringLiteral);
+          expect(typeNode.typeArguments[0].text).toBe('api::foo.foo');
+
+          expect(typeNode.typeArguments[1].kind).toBe(ts.SyntaxKind.StringLiteral);
+          expect(typeNode.typeArguments[1].text).toBe('morphMany');
+        });
+      });
+
+      describe('Component', () => {
+        test('Repeatable component', () => {
+          const attribute = { type: 'component', component: 'default.comp', repeatable: true };
+          const typeNode = getAttributeType('foo', attribute);
+
+          defaultAssertions(typeNode, 'ComponentAttribute');
+
+          expect(typeNode.typeArguments).toHaveLength(2);
+
+          expect(typeNode.typeArguments[0].kind).toBe(ts.SyntaxKind.StringLiteral);
+          expect(typeNode.typeArguments[0].text).toBe('default.comp');
+
+          expect(typeNode.typeArguments[1].kind).toBe(ts.SyntaxKind.TrueKeyword);
+        });
+
+        test('Non repeatable component', () => {
+          const attribute = { type: 'component', component: 'default.comp' };
+          const typeNode = getAttributeType('foo', attribute);
+
+          defaultAssertions(typeNode, 'ComponentAttribute');
+
+          expect(typeNode.typeArguments).toHaveLength(1);
+
+          expect(typeNode.typeArguments[0].kind).toBe(ts.SyntaxKind.StringLiteral);
+          expect(typeNode.typeArguments[0].text).toBe('default.comp');
+        });
+      });
+
+      describe('Dynamic Zone', () => {
+        test('Dynamic Zone with an array of components (targets)', () => {
+          const attribute = { type: 'dynamiczone', components: ['default.comp1', 'default.comp2'] };
+          const typeNode = getAttributeType('foo', attribute);
+
+          defaultAssertions(typeNode, 'DynamicZoneAttribute');
+
+          expect(typeNode.typeArguments).toHaveLength(1);
+
+          const [typeArgument] = typeNode.typeArguments;
+
+          expect(typeArgument.kind).toBe(ts.SyntaxKind.TupleType);
+          expect(typeArgument.elements).toHaveLength(2);
+
+          expect(typeArgument.elements[0].kind).toBe(ts.SyntaxKind.StringLiteral);
+          expect(typeArgument.elements[0].text).toBe('default.comp1');
+
+          expect(typeArgument.elements[1].kind).toBe(ts.SyntaxKind.StringLiteral);
+          expect(typeArgument.elements[1].text).toBe('default.comp2');
         });
       });
     });
   });
 
-  // TODO
-  // describe('Get Attribute Modifiers', () => {});
+  describe('Get Attribute Modifiers', () => {
+    describe('Units', () => {
+      describe('Required', () => {
+        test('No required', () => {
+          const attribute = {};
+          const modifiers = getAttributeModifiers(attribute);
+
+          expect(modifiers).toHaveLength(0);
+        });
+
+        test('Required: false', () => {
+          const attribute = { required: false };
+          const modifiers = getAttributeModifiers(attribute);
+
+          expect(modifiers).toHaveLength(0);
+        });
+
+        test('Required: true', () => {
+          const attribute = { required: true };
+          const modifiers = getAttributeModifiers(attribute);
+
+          expect(modifiers).toHaveLength(1);
+          expect(modifiers[0].kind).toBe(ts.SyntaxKind.TypeReference);
+          expect(modifiers[0].typeName.escapedText).toBe('RequiredAttribute');
+        });
+      });
+
+      describe('Private', () => {
+        test('No private', () => {
+          const attribute = {};
+          const modifiers = getAttributeModifiers(attribute);
+
+          expect(modifiers).toHaveLength(0);
+        });
+
+        test('Private: false', () => {
+          const attribute = { private: false };
+          const modifiers = getAttributeModifiers(attribute);
+
+          expect(modifiers).toHaveLength(0);
+        });
+
+        test('Private: true', () => {
+          const attribute = { private: true };
+          const modifiers = getAttributeModifiers(attribute);
+
+          expect(modifiers).toHaveLength(1);
+          expect(modifiers[0].kind).toBe(ts.SyntaxKind.TypeReference);
+          expect(modifiers[0].typeName.escapedText).toBe('PrivateAttribute');
+        });
+      });
+
+      describe('Unique', () => {
+        test('No unique', () => {
+          const attribute = {};
+          const modifiers = getAttributeModifiers(attribute);
+
+          expect(modifiers).toHaveLength(0);
+        });
+
+        test('Unique: false', () => {
+          const attribute = { unique: false };
+          const modifiers = getAttributeModifiers(attribute);
+
+          expect(modifiers).toHaveLength(0);
+        });
+
+        test('Unique: true', () => {
+          const attribute = { unique: true };
+          const modifiers = getAttributeModifiers(attribute);
+
+          expect(modifiers).toHaveLength(1);
+          expect(modifiers[0].kind).toBe(ts.SyntaxKind.TypeReference);
+          expect(modifiers[0].typeName.escapedText).toBe('UniqueAttribute');
+        });
+      });
+
+      describe('Configurable', () => {
+        test('No configurable', () => {
+          const attribute = {};
+          const modifiers = getAttributeModifiers(attribute);
+
+          expect(modifiers).toHaveLength(0);
+        });
+
+        test('Configurable: false', () => {
+          const attribute = { configurable: false };
+          const modifiers = getAttributeModifiers(attribute);
+
+          expect(modifiers).toHaveLength(0);
+        });
+
+        test('Configurable: true', () => {
+          const attribute = { configurable: true };
+          const modifiers = getAttributeModifiers(attribute);
+
+          expect(modifiers).toHaveLength(1);
+          expect(modifiers[0].kind).toBe(ts.SyntaxKind.TypeReference);
+          expect(modifiers[0].typeName.escapedText).toBe('ConfigurableAttribute');
+        });
+      });
+
+      describe('Plugin Options', () => {
+        test('No plugin options', () => {
+          const attribute = {};
+          const modifiers = getAttributeModifiers(attribute);
+
+          expect(modifiers).toHaveLength(0);
+        });
+
+        test('Plugin Options: { foo: { enabled: true } }', () => {
+          const attribute = { pluginOptions: { foo: { enabled: true } } };
+          const modifiers = getAttributeModifiers(attribute);
+
+          expect(modifiers).toHaveLength(1);
+          expect(modifiers[0].kind).toBe(ts.SyntaxKind.TypeReference);
+          expect(modifiers[0].typeName.escapedText).toBe('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);
+          expect(modifiers[0].typeArguments[0].members[0].kind).toBe(
+            ts.SyntaxKind.PropertyDeclaration
+          );
+          expect(modifiers[0].typeArguments[0].members[0].name.escapedText).toBe('foo');
+          expect(modifiers[0].typeArguments[0].members[0].type.kind).toBe(
+            ts.SyntaxKind.TypeLiteral
+          );
+          expect(modifiers[0].typeArguments[0].members[0].type.members).toHaveLength(1);
+          expect(modifiers[0].typeArguments[0].members[0].type.members[0].kind).toBe(
+            ts.SyntaxKind.PropertyDeclaration
+          );
+          expect(modifiers[0].typeArguments[0].members[0].type.members[0].name.escapedText).toBe(
+            'enabled'
+          );
+          expect(modifiers[0].typeArguments[0].members[0].type.members[0].type.kind).toBe(
+            ts.SyntaxKind.TrueKeyword
+          );
+        });
+      });
+
+      describe('Min / Max', () => {
+        test('No min or max', () => {
+          const attribute = {};
+          const modifiers = getAttributeModifiers(attribute);
+
+          expect(modifiers).toHaveLength(0);
+        });
+
+        test('Min: 2, no Max', () => {
+          const attribute = { min: 2 };
+          const modifiers = getAttributeModifiers(attribute);
+
+          expect(modifiers).toHaveLength(1);
+
+          expect(modifiers[0].kind).toBe(ts.SyntaxKind.TypeReference);
+          expect(modifiers[0].typeName.escapedText).toBe('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);
+
+          // 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');
+        });
+
+        test('No Min, Max: 3', () => {
+          const attribute = { max: 3 };
+          const modifiers = getAttributeModifiers(attribute);
+
+          expect(modifiers).toHaveLength(1);
+
+          expect(modifiers[0].kind).toBe(ts.SyntaxKind.TypeReference);
+          expect(modifiers[0].typeName.escapedText).toBe('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);
+
+          // 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');
+        });
+
+        test('Min: 4, Max: 12', () => {
+          const attribute = { min: 4, max: 12 };
+          const modifiers = getAttributeModifiers(attribute);
+
+          expect(modifiers).toHaveLength(1);
+
+          expect(modifiers[0].kind).toBe(ts.SyntaxKind.TypeReference);
+          expect(modifiers[0].typeName.escapedText).toBe('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);
+
+          // 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(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');
+        });
+      });
+
+      describe('MinLength / MaxLength', () => {
+        test('No minLength or maxLength', () => {
+          const attribute = {};
+          const modifiers = getAttributeModifiers(attribute);
+
+          expect(modifiers).toHaveLength(0);
+        });
+
+        test('MinLength: 2, no MaxLength', () => {
+          const attribute = { minLength: 2 };
+          const modifiers = getAttributeModifiers(attribute);
+
+          expect(modifiers).toHaveLength(1);
+
+          expect(modifiers[0].kind).toBe(ts.SyntaxKind.TypeReference);
+          expect(modifiers[0].typeName.escapedText).toBe('SetMinMaxLength');
+
+          expect(modifiers[0].typeArguments).toHaveLength(1);
+          expect(modifiers[0].typeArguments[0].kind).toBe(ts.SyntaxKind.TypeLiteral);
+          expect(modifiers[0].typeArguments[0].members).toHaveLength(1);
+
+          // Min
+          expect(modifiers[0].typeArguments[0].members[0].kind).toBe(
+            ts.SyntaxKind.PropertyDeclaration
+          );
+          expect(modifiers[0].typeArguments[0].members[0].name.escapedText).toBe('minLength');
+          expect(modifiers[0].typeArguments[0].members[0].type.kind).toBe(
+            ts.SyntaxKind.NumericLiteral
+          );
+          expect(modifiers[0].typeArguments[0].members[0].type.text).toBe('2');
+        });
+
+        test('No MinLength, MaxLength: 3', () => {
+          const attribute = { maxLength: 3 };
+          const modifiers = getAttributeModifiers(attribute);
+
+          expect(modifiers).toHaveLength(1);
+
+          expect(modifiers[0].kind).toBe(ts.SyntaxKind.TypeReference);
+          expect(modifiers[0].typeName.escapedText).toBe('SetMinMaxLength');
+
+          expect(modifiers[0].typeArguments).toHaveLength(1);
+          expect(modifiers[0].typeArguments[0].kind).toBe(ts.SyntaxKind.TypeLiteral);
+          expect(modifiers[0].typeArguments[0].members).toHaveLength(1);
+
+          // Min
+          expect(modifiers[0].typeArguments[0].members[0].kind).toBe(
+            ts.SyntaxKind.PropertyDeclaration
+          );
+          expect(modifiers[0].typeArguments[0].members[0].name.escapedText).toBe('maxLength');
+          expect(modifiers[0].typeArguments[0].members[0].type.kind).toBe(
+            ts.SyntaxKind.NumericLiteral
+          );
+          expect(modifiers[0].typeArguments[0].members[0].type.text).toBe('3');
+        });
+
+        test('MinLength: 4, MaxLength: 12', () => {
+          const attribute = { minLength: 4, maxLength: 12 };
+          const modifiers = getAttributeModifiers(attribute);
+
+          expect(modifiers).toHaveLength(1);
+
+          expect(modifiers[0].kind).toBe(ts.SyntaxKind.TypeReference);
+          expect(modifiers[0].typeName.escapedText).toBe('SetMinMaxLength');
+
+          expect(modifiers[0].typeArguments).toHaveLength(1);
+          expect(modifiers[0].typeArguments[0].kind).toBe(ts.SyntaxKind.TypeLiteral);
+          expect(modifiers[0].typeArguments[0].members).toHaveLength(2);
+
+          // Min
+          expect(modifiers[0].typeArguments[0].members[0].kind).toBe(
+            ts.SyntaxKind.PropertyDeclaration
+          );
+          expect(modifiers[0].typeArguments[0].members[0].name.escapedText).toBe('minLength');
+          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(modifiers[0].typeArguments[0].members[1].kind).toBe(
+            ts.SyntaxKind.PropertyDeclaration
+          );
+          expect(modifiers[0].typeArguments[0].members[1].name.escapedText).toBe('maxLength');
+          expect(modifiers[0].typeArguments[0].members[1].type.kind).toBe(
+            ts.SyntaxKind.NumericLiteral
+          );
+          expect(modifiers[0].typeArguments[0].members[1].type.text).toBe('12');
+        });
+      });
+
+      describe('Default', () => {
+        test('No default', () => {
+          const attribute = {};
+          const modifiers = getAttributeModifiers(attribute);
+
+          expect(modifiers).toHaveLength(0);
+        });
+
+        test('Default: true', () => {
+          const attribute = { default: true };
+          const modifiers = getAttributeModifiers(attribute);
+
+          expect(modifiers).toHaveLength(1);
+
+          expect(modifiers[0].kind).toBe(ts.SyntaxKind.TypeReference);
+          expect(modifiers[0].typeName.escapedText).toBe('DefaultTo');
+
+          expect(modifiers[0].typeArguments).toHaveLength(1);
+          expect(modifiers[0].typeArguments[0].kind).toBe(ts.SyntaxKind.TrueKeyword);
+        });
+
+        test('Default: { enabled: true }', () => {
+          const attribute = { default: { enabled: true } };
+          const modifiers = getAttributeModifiers(attribute);
+
+          expect(modifiers).toHaveLength(1);
+
+          expect(modifiers[0].kind).toBe(ts.SyntaxKind.TypeReference);
+          expect(modifiers[0].typeName.escapedText).toBe('DefaultTo');
+
+          expect(modifiers[0].typeArguments).toHaveLength(1);
+          expect(modifiers[0].typeArguments[0].kind).toBe(ts.SyntaxKind.TypeLiteral);
+          expect(modifiers[0].typeArguments[0].members).toHaveLength(1);
+          expect(modifiers[0].typeArguments[0].members[0].kind).toBe(
+            ts.SyntaxKind.PropertyDeclaration
+          );
+          expect(modifiers[0].typeArguments[0].members[0].name.escapedText).toBe('enabled');
+          expect(modifiers[0].typeArguments[0].members[0].type.kind).toBe(
+            ts.SyntaxKind.TrueKeyword
+          );
+        });
+      });
+    });
+  });
 });

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

@@ -0,0 +1,108 @@
+'use strict';
+
+jest.mock('../../../generators/schemas/utils', () => ({
+  getSchemaInterfaceName: jest.fn(),
+}));
+
+const ts = require('typescript');
+const { get } = require('lodash/fp');
+
+const { generateGlobalDefinition } = require('../../../generators/schemas/global');
+const { getSchemaInterfaceName } = require('../../../generators/schemas/utils');
+
+const getSchemasInterfaceNode = get('body.statements[0].body.statements[0]');
+
+describe('Global', () => {
+  afterAll(() => {
+    jest.resetAllMocks();
+  });
+
+  const assertGlobalNodeStructure = node => {
+    // "declare global"
+    expect(node.kind).toBe(ts.SyntaxKind.ModuleDeclaration);
+    expect(node.modifiers).toHaveLength(1);
+    expect(node.modifiers[0].kind).toBe(ts.SyntaxKind.DeclareKeyword);
+    expect(node.name.originalKeywordKind).toBe(ts.SyntaxKind.GlobalKeyword);
+    expect(node.name.escapedText).toBe('global');
+
+    // "namespace Strapi"
+    const [strapiNamespace] = node.body.statements;
+
+    expect(strapiNamespace.kind).toBe(ts.SyntaxKind.ModuleDeclaration);
+    expect(strapiNamespace.name.kind).toBe(ts.SyntaxKind.Identifier);
+    expect(strapiNamespace.name.escapedText).toBe('Strapi');
+
+    // "interface Schemas"
+    const [schemasInterface] = strapiNamespace.body.statements;
+
+    expect(schemasInterface.kind).toBe(ts.SyntaxKind.InterfaceDeclaration);
+    expect(schemasInterface.name.escapedText).toBe('Schemas');
+  };
+
+  describe('Generate Global Definition', () => {
+    beforeEach(() => {
+      jest.resetAllMocks();
+    });
+
+    test('With empty definition', () => {
+      const definitions = [];
+
+      const globalNode = generateGlobalDefinition(definitions);
+
+      assertGlobalNodeStructure(globalNode);
+
+      expect(getSchemaInterfaceName).not.toHaveBeenCalled();
+
+      const schemasNode = getSchemasInterfaceNode(globalNode);
+
+      expect(schemasNode.members).toHaveLength(0);
+    });
+
+    test('With no definition', () => {
+      const globalNode = generateGlobalDefinition();
+
+      assertGlobalNodeStructure(globalNode);
+
+      expect(getSchemaInterfaceName).not.toHaveBeenCalled();
+
+      const schemasNode = getSchemasInterfaceNode(globalNode);
+
+      expect(schemasNode.members).toHaveLength(0);
+    });
+
+    test('With multiple definitions', () => {
+      const definitions = [
+        { schema: { uid: 'api::foo.foo' } },
+        { schema: { uid: 'api::bar.bar' } },
+        { schema: { uid: 'api::foobar.foobar' } },
+        { schema: { uid: 'default.barfoo' } },
+      ];
+
+      getSchemaInterfaceName.mockReturnValue('Placeholder');
+
+      const globalNode = generateGlobalDefinition(definitions);
+
+      assertGlobalNodeStructure(globalNode);
+
+      const schemasNode = getSchemasInterfaceNode(globalNode);
+
+      expect(schemasNode.members).toHaveLength(definitions.length);
+
+      definitions.forEach(({ schema }, index) => {
+        const { uid } = schema;
+        const node = schemasNode.members[index];
+
+        expect(node.kind).toBe(ts.SyntaxKind.PropertySignature);
+
+        expect(getSchemaInterfaceName).toHaveBeenCalledWith(uid);
+
+        expect(node.name.kind).toBe(ts.SyntaxKind.StringLiteral);
+        expect(node.name.text).toBe(uid);
+        expect(node.name.singleQuote).toBeTruthy();
+
+        expect(node.type.kind).toBe(ts.SyntaxKind.TypeReference);
+        expect(node.type.typeName.escapedText).toBe('Placeholder');
+      });
+    });
+  });
+});

package/lib/generators/schemas/attributes.js

@@ -22,7 +22,7 @@ const attributeToPropertySignature = (schema, attributeName, attribute) => {
     return null;
   }
 
-  const modifiers = getAttributeModifiers(attributeName, attribute);
+  const modifiers = getAttributeModifiers(attribute);
 
   const nodes = [baseType, ...modifiers];
 
@@ -61,11 +61,10 @@ const getAttributeType = (attributeName, attribute, uid) => {
 /**
  * Collect every modifier node from an attribute
  *
- * @param {string} _attributeName
  * @param {object} attribute
  * @returns {object[]}
  */
-const getAttributeModifiers = (_attributeName, attribute) => {
+const getAttributeModifiers = attribute => {
   const modifiers = [];
 
   // Required
@@ -112,6 +111,7 @@ const getAttributeModifiers = (_attributeName, 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');
 
@@ -223,11 +223,7 @@ const mappers = {
   enumeration({ attribute }) {
     const { enum: enumValues } = attribute;
 
-    if (Array.isArray(enumValues)) {
-      return ['EnumerationAttribute', [toTypeLiteral(enumValues)]];
-    }
-
-    return ['EnumerationAttribute'];
+    return ['EnumerationAttribute', [toTypeLiteral(enumValues)]];
   },
   boolean() {
     return ['BooleanAttribute'];

package/lib/generators/schemas/index.js

@@ -34,7 +34,13 @@ const DEFAULT_OUT_FILENAME = 'schemas.d.ts';
  * @param {boolean} [options.verbose]
  */
 const generateSchemasDefinitions = async (options = {}) => {
-  const { strapi, outDir = process.cwd(), file = DEFAULT_OUT_FILENAME, verbose = false } = options;
+  const {
+    strapi,
+    outDir = process.cwd(),
+    file = DEFAULT_OUT_FILENAME,
+    verbose = false,
+    silent = false,
+  } = options;
 
   const schemas = getAllStrapiSchemas(strapi);
 
@@ -74,9 +80,7 @@ const generateSchemasDefinitions = async (options = {}) => {
 
   const definitionFilepath = await saveDefinitionToFileSystem(outDir, file, formattedOutput);
 
-  if (verbose) {
-    logDebugInformation(schemasDefinitions, { filepath: definitionFilepath });
-  }
+  logDebugInformation(schemasDefinitions, { filepath: definitionFilepath, verbose, silent });
 };
 
 const emitDefinitions = definitions => {
@@ -108,7 +112,7 @@ const saveDefinitionToFileSystem = async (dir, file, content) => {
  * Uses the existing config if one is defined in the project.
  *
  * @param {string} content
- * @returns {string}
+ * @returns {Promise<string>}
  */
 const format = async content => {
   const configFile = await prettier.resolveConfigFile();
@@ -127,51 +131,55 @@ const format = async content => {
 };
 
 const logDebugInformation = (definitions, options = {}) => {
-  const { filepath } = options;
-
-  const table = new CLITable({
-    head: [
-      chalk.bold(chalk.green('Model Type')),
-      chalk.bold(chalk.blue('UID')),
-      chalk.bold(chalk.blue('Type')),
-      chalk.bold(chalk.gray('Attributes Count')),
-    ],
-    colAligns: ['center', 'left', 'left', 'center'],
-  });
-
-  const sortedDefinitions = definitions.map(def => ({
-    ...def,
-    attributesCount: getDefinitionAttributesCount(def.definition),
-  }));
+  const { filepath, verbose, silent } = options;
 
-  for (const { schema, attributesCount } of sortedDefinitions) {
-    const modelType = fp.upperFirst(getSchemaModelType(schema));
-    const interfaceType = getSchemaInterfaceName(schema.uid);
-
-    table.push([
-      chalk.greenBright(modelType),
-      chalk.blue(schema.uid),
-      chalk.blue(interfaceType),
-      chalk.grey(fp.isNil(attributesCount) ? 'N/A' : attributesCount),
-    ]);
+  if (verbose) {
+    const table = new CLITable({
+      head: [
+        chalk.bold(chalk.green('Model Type')),
+        chalk.bold(chalk.blue('UID')),
+        chalk.bold(chalk.blue('Type')),
+        chalk.bold(chalk.gray('Attributes Count')),
+      ],
+      colAligns: ['center', 'left', 'left', 'center'],
+    });
+
+    const sortedDefinitions = definitions.map(def => ({
+      ...def,
+      attributesCount: getDefinitionAttributesCount(def.definition),
+    }));
+
+    for (const { schema, attributesCount } of sortedDefinitions) {
+      const modelType = fp.upperFirst(getSchemaModelType(schema));
+      const interfaceType = getSchemaInterfaceName(schema.uid);
+
+      table.push([
+        chalk.greenBright(modelType),
+        chalk.blue(schema.uid),
+        chalk.blue(interfaceType),
+        chalk.grey(fp.isNil(attributesCount) ? 'N/A' : attributesCount),
+      ]);
+    }
+
+    // Table
+    console.log(table.toString());
   }
 
-  // Table
-  console.log(table.toString());
-
-  // Metrics
-  console.log(
-    chalk.greenBright(
-      `Generated ${definitions.length} type definition for your Strapi application's schemas.`
-    )
-  );
+  if (!silent) {
+    // Metrics
+    console.log(
+      chalk.greenBright(
+        `Generated ${definitions.length} type definition for your Strapi application's schemas.`
+      )
+    );
 
-  // Filepath
-  const relativePath = path.relative(process.cwd(), filepath);
+    // Filepath
+    const relativePath = path.relative(process.cwd(), filepath);
 
-  console.log(
-    chalk.grey(`The definitions file has been generated here: ${chalk.bold(relativePath)}`)
-  );
+    console.log(
+      chalk.grey(`The definitions file has been generated here: ${chalk.bold(relativePath)}`)
+    );
+  }
 };
 
 module.exports = generateSchemasDefinitions;

package/lib/generators/schemas/utils.js

@@ -11,6 +11,7 @@ const {
   isNull,
   isString,
   isNumber,
+  isDate,
   isArray,
   isBoolean,
   propEq,
@@ -101,6 +102,10 @@ const toTypeLiteral = data => {
     return factory.createTupleTypeNode(data.map(item => toTypeLiteral(item)));
   }
 
+  if (isDate(data)) {
+    return factory.createStringLiteral(data.toISOString());
+  }
+
   if (typeof data !== 'object') {
     throw new Error(`Cannot convert to object literal. Unknown type "${typeof data}"`);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/typescript-utils",
-  "version": "4.3.0-beta.2",
+  "version": "4.3.2-alpha.0",
   "description": "Typescript support for Strapi",
   "keywords": [
     "strapi",
@@ -35,5 +35,5 @@
     "node": ">=12.22.0 <=16.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "42aba356ad1b0751584d3b375e83baa4a2c18f65"
+  "gitHead": "8ab2db1497c3a5a805173b2d92248648b40a6f65"
 }