@strapi/typescript-utils 4.3.0-beta.1 → 4.3.0-beta.2

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

@@ -0,0 +1,81 @@
+'use strict';
+
+jest.mock('../../../generators/schemas/imports', () => ({ addImport: jest.fn() }));
+
+const consoleWarnMock = jest.spyOn(console, 'warn').mockImplementation();
+
+const ts = require('typescript');
+
+const { getAttributeType } = require('../../../generators/schemas/attributes');
+const { addImport } = require('../../../generators/schemas/imports');
+
+describe('Attributes', () => {
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  // TODO
+  // describe('Attribute to Property Signature', () => {});
+
+  // TODO
+  // describe('Mappers', () => {});
+
+  describe('Get Attribute Type', () => {
+    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' });
+
+      expect(typeNode).toBeNull();
+      expect(consoleWarnMock).toHaveBeenCalledWith(
+        '"foo" attribute from "undefined" has an invalid type: "invalid"'
+      );
+      expect(addImport).not.toHaveBeenCalled();
+    });
+
+    test('Return a basic type node without generic type parameter', () => {
+      const typeNode = getAttributeType('foo', { type: 'string' });
+
+      expect(ts.isTypeNode(typeNode)).toBeTruthy();
+
+      expect(typeNode.kind).toBe(ts.SyntaxKind.TypeReference);
+      expect(typeNode.typeName.escapedText).toBe('StringAttribute');
+      expect(typeNode.typeArguments).toBeUndefined();
+
+      expect(consoleWarnMock).not.toHaveBeenCalled();
+      expect(addImport).toHaveBeenCalledWith('StringAttribute');
+    });
+
+    describe('Complex types (with generic type parameters)', () => {
+      const defaultAssertions = (typeNode, typeName) => {
+        expect(ts.isTypeNode(typeNode)).toBeTruthy();
+
+        expect(typeNode.kind).toBe(ts.SyntaxKind.TypeReference);
+        expect(typeNode.typeName.escapedText).toBe(typeName);
+
+        expect(consoleWarnMock).not.toHaveBeenCalled();
+        expect(addImport).toHaveBeenCalledWith(typeName);
+      };
+
+      test('Enumeration', () => {
+        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);
+        });
+      });
+    });
+  });
+
+  // TODO
+  // describe('Get Attribute Modifiers', () => {});
+});

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

@@ -0,0 +1,54 @@
+'use strict';
+
+const ts = require('typescript');
+
+const {
+  addImport,
+  generateImportDefinition,
+  getImports,
+} = require('../../../generators/schemas/imports');
+
+describe('Imports', () => {
+  test('When first loaded, the list of imports should be empty', () => {
+    expect(getImports()).toHaveLength(0);
+  });
+
+  test('Can add new imports to the list', () => {
+    addImport('foo');
+    addImport('bar');
+
+    expect(getImports()).toHaveLength(2);
+  });
+
+  test('When adding an already registered import, ignore it', () => {
+    addImport('foo');
+
+    expect(getImports()).toHaveLength(2);
+  });
+
+  test('Generate an import type definition containing the registered import', () => {
+    const def = generateImportDefinition();
+
+    expect(def.kind).toBe(ts.SyntaxKind.ImportDeclaration);
+
+    // 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);
+
+    const { elements } = def.importClause.namedBindings;
+
+    expect(elements).toHaveLength(2);
+
+    // 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);
+    });
+  });
+});

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

@@ -0,0 +1,362 @@
+'use strict';
+
+const ts = require('typescript');
+const { factory } = require('typescript');
+
+const {
+  getAllStrapiSchemas,
+  getDefinitionAttributesCount,
+  getSchemaExtendsTypeName,
+  getSchemaInterfaceName,
+  getSchemaModelType,
+  getTypeNode,
+  toTypeLiteral,
+} = require('../../../generators/schemas/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,
+        undefined,
+        members
+      );
+    };
+
+    const createPropertyDeclaration = (name, type) => {
+      return factory.createPropertyDeclaration(
+        undefined,
+        undefined,
+        factory.createIdentifier(name),
+        undefined,
+        type
+      );
+    };
+
+    test('Returns null if there are no members in the parent node', () => {
+      const mainNode = createMainNode();
+
+      const count = getDefinitionAttributesCount(mainNode);
+
+      expect(count).toBeNull();
+    });
+
+    test('Returns null if there are members in the parent node, but none named "attributes"', () => {
+      const mainNode = createMainNode([
+        createPropertyDeclaration(
+          'bar',
+          factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
+        ),
+        createPropertyDeclaration(
+          'foobar',
+          factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)
+        ),
+      ]);
+
+      const count = getDefinitionAttributesCount(mainNode);
+
+      expect(count).toBeNull();
+    });
+
+    test('Returns the number of attributes if the property is present', () => {
+      const mainNode = createMainNode([
+        createPropertyDeclaration(
+          'bar',
+          factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
+        ),
+        createPropertyDeclaration(
+          'attributes',
+          factory.createTypeLiteralNode([
+            createPropertyDeclaration(
+              'a',
+              factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
+            ),
+            createPropertyDeclaration(
+              'b',
+              factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)
+            ),
+            createPropertyDeclaration(
+              'c',
+              factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword)
+            ),
+          ])
+        ),
+        createPropertyDeclaration(
+          'foobar',
+          factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)
+        ),
+      ]);
+
+      const count = getDefinitionAttributesCount(mainNode);
+
+      expect(count).toBe(3);
+    });
+
+    test("Returns 0 if the attributes node is present but don't have any members", () => {
+      const mainNode = createMainNode([
+        createPropertyDeclaration('attributes', factory.createTypeLiteralNode()),
+        createPropertyDeclaration(
+          'foobar',
+          factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)
+        ),
+      ]);
+
+      const count = getDefinitionAttributesCount(mainNode);
+
+      expect(count).toBe(0);
+    });
+  });
+
+  describe('Get Schema Model Type', () => {
+    test.each([
+      [{ modelType: 'component', kind: null }, 'component'],
+      [{ modelType: 'contentType', kind: 'singleType' }, 'singleType'],
+      [{ modelType: 'contentType', kind: 'collectionType' }, 'collectionType'],
+      [{ modelType: 'invalidType', kind: 'foo' }, null],
+    ])('%p to be evaluated to %p', (schema, expected) => {
+      expect(getSchemaModelType(schema)).toBe(expected);
+    });
+  });
+
+  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'],
+    ])("Expect %p to generate %p as the base type for a schema's interface", (schema, expected) => {
+      expect(getSchemaExtendsTypeName(schema)).toBe(expected);
+    });
+  });
+
+  describe('Get Schema Interface Name', () => {
+    test.each([
+      ['api::foo.foo', 'ApiFooFoo'],
+      ['plugin::bar.foo', 'PluginBarFoo'],
+      ['default.dish', 'DefaultDish'],
+    ])('Should transform UID (%p) to interface name (%p)', (uid, interfaceName) => {
+      expect(getSchemaInterfaceName(uid)).toBe(interfaceName);
+    });
+  });
+
+  describe('Get Type Node', () => {
+    test('Create a valid type reference node based on the given generic parameters', () => {
+      const node = getTypeNode('FooBar', [
+        factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
+        factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
+      ]);
+
+      expect(node.typeArguments).toHaveLength(2);
+
+      expect(node.typeArguments[0].kind).toBe(ts.SyntaxKind.StringKeyword);
+      expect(node.typeArguments[1].kind).toBe(ts.SyntaxKind.NumberKeyword);
+    });
+
+    test('Create a valid empty type reference node', () => {
+      const node = getTypeNode('FooBar');
+
+      expect(node.typeArguments).toBeUndefined();
+    });
+  });
+
+  describe('To Type Literal', () => {
+    test('String', () => {
+      const node = toTypeLiteral('foo');
+
+      expect(node.kind).toBe(ts.SyntaxKind.StringLiteral);
+      expect(node.text).toBe('foo');
+    });
+
+    test('Number', () => {
+      const node = toTypeLiteral(42);
+
+      expect(node.kind).toBe(ts.SyntaxKind.FirstLiteralToken);
+      expect(node.text).toBe('42');
+    });
+
+    test('Boolean', () => {
+      const trueNode = toTypeLiteral(true);
+      const falseNode = toTypeLiteral(false);
+
+      expect(trueNode.kind).toBe(ts.SyntaxKind.TrueKeyword);
+      expect(falseNode.kind).toBe(ts.SyntaxKind.FalseKeyword);
+    });
+
+    test('undefined', () => {
+      const node = toTypeLiteral(undefined);
+
+      expect(node.kind).toBe(ts.SyntaxKind.LiteralType);
+      expect(node.literal).toBe(ts.SyntaxKind.UndefinedKeyword);
+    });
+
+    test('null', () => {
+      const node = toTypeLiteral(null);
+
+      expect(node.kind).toBe(ts.SyntaxKind.LiteralType);
+      expect(node.literal).toBe(ts.SyntaxKind.NullKeyword);
+    });
+
+    test('Array (empty)', () => {
+      const node = toTypeLiteral([]);
+
+      expect(node.kind).toBe(ts.SyntaxKind.TupleType);
+      expect(node.elements).toHaveLength(0);
+    });
+
+    test('Array (with elements)', () => {
+      const node = toTypeLiteral(['foo', 2]);
+
+      expect(node.kind).toBe(ts.SyntaxKind.TupleType);
+      expect(node.elements).toHaveLength(2);
+
+      expect(node.elements[0].kind).toBe(ts.SyntaxKind.StringLiteral);
+      expect(node.elements[0].text).toBe('foo');
+
+      expect(node.elements[1].kind).toBe(ts.SyntaxKind.FirstLiteralToken);
+      expect(node.elements[1].text).toBe('2');
+    });
+
+    test('Array (nested)', () => {
+      const node = toTypeLiteral(['foo', ['bar', 'foobar']]);
+
+      expect(node.kind).toBe(ts.SyntaxKind.TupleType);
+      expect(node.elements).toHaveLength(2);
+
+      expect(node.elements[0].kind).toBe(ts.SyntaxKind.StringLiteral);
+      expect(node.elements[0].text).toBe('foo');
+
+      expect(node.elements[1].kind).toBe(ts.SyntaxKind.TupleType);
+      expect(node.elements[1].elements).toHaveLength(2);
+
+      expect(node.elements[1].elements[0].kind).toBe(ts.SyntaxKind.StringLiteral);
+      expect(node.elements[1].elements[0].text).toBe('bar');
+
+      expect(node.elements[1].elements[1].kind).toBe(ts.SyntaxKind.StringLiteral);
+      expect(node.elements[1].elements[1].text).toBe('foobar');
+    });
+
+    test('Array (with object)', () => {
+      const node = toTypeLiteral([{ foo: 'bar', bar: true }]);
+
+      expect(node.kind).toBe(ts.SyntaxKind.TupleType);
+      expect(node.elements).toHaveLength(1);
+
+      const objectNode = node.elements[0];
+
+      expect(objectNode.kind).toBe(ts.SyntaxKind.TypeLiteral);
+      expect(objectNode.members).toHaveLength(2);
+
+      expect(objectNode.members[0].kind).toBe(ts.SyntaxKind.PropertyDeclaration);
+      expect(objectNode.members[0].name.escapedText).toBe('foo');
+      expect(objectNode.members[0].type.kind).toBe(ts.SyntaxKind.StringLiteral);
+      expect(objectNode.members[0].type.text).toBe('bar');
+
+      expect(objectNode.members[1].kind).toBe(ts.SyntaxKind.PropertyDeclaration);
+      expect(objectNode.members[1].name.escapedText).toBe('bar');
+      expect(objectNode.members[1].type.kind).toBe(ts.SyntaxKind.TrueKeyword);
+    });
+
+    test('Object', () => {
+      const node = toTypeLiteral({ foo: ['bar', true, 2], bar: null });
+
+      expect(node.kind).toBe(ts.SyntaxKind.TypeLiteral);
+      expect(node.members).toHaveLength(2);
+
+      const [firstMember, secondMember] = node.members;
+
+      expect(firstMember.kind).toBe(ts.SyntaxKind.PropertyDeclaration);
+      expect(firstMember.name.escapedText).toBe('foo');
+      expect(firstMember.type.kind).toBe(ts.SyntaxKind.TupleType);
+      expect(firstMember.type.elements).toHaveLength(3);
+      expect(firstMember.type.elements[0].kind).toBe(ts.SyntaxKind.StringLiteral);
+      expect(firstMember.type.elements[1].kind).toBe(ts.SyntaxKind.TrueKeyword);
+      expect(firstMember.type.elements[2].kind).toBe(ts.SyntaxKind.FirstLiteralToken);
+
+      expect(secondMember.kind).toBe(ts.SyntaxKind.PropertyDeclaration);
+      expect(secondMember.name.escapedText).toBe('bar');
+      expect(secondMember.type.kind).toBe(ts.SyntaxKind.LiteralType);
+      expect(secondMember.type.literal).toBe(ts.SyntaxKind.NullKeyword);
+    });
+
+    test('Object with complex keys', () => {
+      const node = toTypeLiteral({ 'foo-bar': 'foobar', foo: 'bar' });
+
+      expect(node.kind).toBe(ts.SyntaxKind.TypeLiteral);
+      expect(node.members).toHaveLength(2);
+
+      const [firstMember, secondMember] = node.members;
+
+      expect(firstMember.kind).toBe(ts.SyntaxKind.PropertyDeclaration);
+      expect(firstMember.name.kind).toBe(ts.SyntaxKind.StringLiteral);
+      expect(firstMember.name.text).toBe('foo-bar');
+      expect(firstMember.type.kind).toBe(ts.SyntaxKind.StringLiteral);
+      expect(firstMember.type.text).toBe('foobar');
+
+      expect(secondMember.kind).toBe(ts.SyntaxKind.PropertyDeclaration);
+      expect(secondMember.name.kind).toBe(ts.SyntaxKind.Identifier);
+      expect(secondMember.name.escapedText).toBe('foo');
+      expect(secondMember.type.kind).toBe(ts.SyntaxKind.StringLiteral);
+      expect(secondMember.type.text).toBe('bar');
+    });
+
+    test('Invalid data type supplied (function)', () => {
+      expect(() => toTypeLiteral(() => {})).toThrowError(
+        'Cannot convert to object literal. Unknown type "function"'
+      );
+    });
+  });
+});

package/lib/generators/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const generateSchemasDefinitions = require('./schemas');
+
+module.exports = {
+  generateSchemasDefinitions,
+};

package/lib/generators/schemas/attributes.js

@@ -0,0 +1,285 @@
+'use strict';
+
+const ts = require('typescript');
+const { factory } = require('typescript');
+const _ = require('lodash/fp');
+
+const { addImport } = require('./imports');
+const { getTypeNode, toTypeLiteral } = require('./utils');
+
+/**
+ * Generate a property signature node for a given attribute
+ *
+ * @param {object} schema
+ * @param {string} attributeName
+ * @param {object} attribute
+ * @returns {object}
+ */
+const attributeToPropertySignature = (schema, attributeName, attribute) => {
+  const baseType = getAttributeType(attributeName, attribute, schema.uid);
+
+  if (baseType === null) {
+    return null;
+  }
+
+  const modifiers = getAttributeModifiers(attributeName, attribute);
+
+  const nodes = [baseType, ...modifiers];
+
+  return factory.createPropertySignature(
+    undefined,
+    factory.createIdentifier(attributeName),
+    undefined,
+    factory.createIntersectionTypeNode(nodes)
+  );
+};
+
+/**
+ * Create the base type node for a given attribute
+ *
+ * @param {string} attributeName
+ * @param {object} attribute
+ * @param {string} uid
+ * @returns {object}
+ */
+const getAttributeType = (attributeName, attribute, uid) => {
+  if (!Object.keys(mappers).includes(attribute.type)) {
+    console.warn(
+      `"${attributeName}" attribute from "${uid}" has an invalid type: "${attribute.type}"`
+    );
+
+    return null;
+  }
+
+  const [attributeType, typeParams] = mappers[attribute.type]({ uid, attribute, attributeName });
+
+  addImport(attributeType);
+
+  return getTypeNode(attributeType, typeParams);
+};
+
+/**
+ * Collect every modifier node from an attribute
+ *
+ * @param {string} _attributeName
+ * @param {object} attribute
+ * @returns {object[]}
+ */
+const getAttributeModifiers = (_attributeName, attribute) => {
+  const modifiers = [];
+
+  // Required
+  if (attribute.required) {
+    addImport('RequiredAttribute');
+
+    modifiers.push(factory.createTypeReferenceNode(factory.createIdentifier('RequiredAttribute')));
+  }
+
+  // Private
+  if (attribute.private) {
+    addImport('PrivateAttribute');
+
+    modifiers.push(factory.createTypeReferenceNode(factory.createIdentifier('PrivateAttribute')));
+  }
+
+  // Unique
+  if (attribute.unique) {
+    addImport('UniqueAttribute');
+
+    modifiers.push(factory.createTypeReferenceNode(factory.createIdentifier('UniqueAttribute')));
+  }
+
+  // Configurable
+  if (attribute.configurable) {
+    addImport('ConfigurableAttribute');
+
+    modifiers.push(
+      factory.createTypeReferenceNode(factory.createIdentifier('ConfigurableAttribute'))
+    );
+  }
+
+  // Plugin Options
+  if (!_.isEmpty(attribute.pluginOptions)) {
+    addImport('SetPluginOptions');
+
+    modifiers.push(
+      factory.createTypeReferenceNode(
+        factory.createIdentifier('SetPluginOptions'),
+        // Transform the pluginOptions object into an object literal expression
+        [toTypeLiteral(attribute.pluginOptions)]
+      )
+    );
+  }
+
+  // Min / Max
+  if (!_.isNil(attribute.min) || !_.isNil(attribute.max)) {
+    addImport('SetMinMax');
+
+    const minMaxProperties = _.pick(['min', 'max'], attribute);
+
+    modifiers.push(
+      factory.createTypeReferenceNode(factory.createIdentifier('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),
+      ])
+    );
+  }
+
+  // Default
+  if (!_.isNil(attribute.default)) {
+    addImport('DefaultTo');
+
+    const defaultLiteral = toTypeLiteral(attribute.default);
+
+    modifiers.push(
+      factory.createTypeReferenceNode(factory.createIdentifier('DefaultTo'), [defaultLiteral])
+    );
+  }
+
+  return modifiers;
+};
+
+const mappers = {
+  string() {
+    return ['StringAttribute'];
+  },
+  text() {
+    return ['TextAttribute'];
+  },
+  richtext() {
+    return ['RichTextAttribute'];
+  },
+  password() {
+    return ['PasswordAttribute'];
+  },
+  email() {
+    return ['EmailAttribute'];
+  },
+  date() {
+    return ['DateAttribute'];
+  },
+  time() {
+    return ['TimeAttribute'];
+  },
+  datetime() {
+    return ['DateTimeAttribute'];
+  },
+  timestamp() {
+    return ['TimestampAttribute'];
+  },
+  integer() {
+    return ['IntegerAttribute'];
+  },
+  biginteger() {
+    return ['BigIntegerAttribute'];
+  },
+  float() {
+    return ['FloatAttribute'];
+  },
+  decimal() {
+    return ['DecimalAttribute'];
+  },
+  uid({ attribute, uid }) {
+    const { targetField, options } = attribute;
+
+    // If there are no params to compute, then return the attribute type alone
+    if (targetField === undefined && options === undefined) {
+      return ['UIDAttribute'];
+    }
+
+    const params = [];
+
+    // If the targetField property is defined, then reference it,
+    // otherwise, put `undefined` keyword type nodes as placeholders
+    const targetFieldParams = _.isUndefined(targetField)
+      ? [
+          factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword),
+          factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword),
+        ]
+      : [factory.createStringLiteral(uid), factory.createStringLiteral(targetField)];
+
+    params.push(...targetFieldParams);
+
+    // If the options property is defined, transform it to
+    // a type literral node and add it to the params list
+    if (_.isObject(options)) {
+      params.push(toTypeLiteral(options));
+    }
+
+    return ['UIDAttribute', params];
+  },
+  enumeration({ attribute }) {
+    const { enum: enumValues } = attribute;
+
+    if (Array.isArray(enumValues)) {
+      return ['EnumerationAttribute', [toTypeLiteral(enumValues)]];
+    }
+
+    return ['EnumerationAttribute'];
+  },
+  boolean() {
+    return ['BooleanAttribute'];
+  },
+  json() {
+    return ['JSONAttribute'];
+  },
+  media() {
+    return ['MediaAttribute'];
+  },
+  relation({ uid, attribute }) {
+    const { relation, target } = attribute;
+
+    const isMorphRelation = relation.toLowerCase().includes('morph');
+
+    if (isMorphRelation) {
+      return [
+        'RelationAttribute',
+        [factory.createStringLiteral(uid, true), factory.createStringLiteral(relation, true)],
+      ];
+    }
+
+    return [
+      'RelationAttribute',
+      [
+        factory.createStringLiteral(uid, true),
+        factory.createStringLiteral(relation, true),
+        factory.createStringLiteral(target, true),
+      ],
+    ];
+  },
+  component({ attribute }) {
+    const target = attribute.component;
+    const params = [factory.createStringLiteral(target, true)];
+
+    if (attribute.repeatable) {
+      params.push(factory.createTrue());
+    }
+
+    return ['ComponentAttribute', params];
+  },
+  dynamiczone({ attribute }) {
+    const componentsParam = factory.createTupleTypeNode(
+      attribute.components.map(component => factory.createStringLiteral(component))
+    );
+
+    return ['DynamicZoneAttribute', [componentsParam]];
+  },
+};
+
+module.exports = attributeToPropertySignature;
+
+module.exports.mappers = mappers;
+module.exports.getAttributeType = getAttributeType;
+module.exports.getAttributeModifiers = getAttributeModifiers;

package/lib/generators/schemas/global.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const ts = require('typescript');
+const { factory } = require('typescript');
+
+const { getSchemaInterfaceName } = require('./utils');
+
+/**
+ * Generate the global module augmentation block
+ *
+ * @param {Array<{ schema: object; definition: ts.TypeNode }>} schemasDefinitions
+ * @returns {ts.ModuleDeclaration}
+ */
+const generateGlobalDefinition = (schemasDefinitions = []) => {
+  const properties = schemasDefinitions.map(schemaDefinitionToPropertySignature);
+
+  return factory.createModuleDeclaration(
+    undefined,
+    [factory.createModifier(ts.SyntaxKind.DeclareKeyword)],
+    factory.createIdentifier('global'),
+    factory.createModuleBlock([
+      factory.createModuleDeclaration(
+        undefined,
+        undefined,
+        factory.createIdentifier('Strapi'),
+        factory.createModuleBlock([
+          factory.createInterfaceDeclaration(
+            undefined,
+            undefined,
+            factory.createIdentifier('Schemas'),
+            undefined,
+            undefined,
+            properties
+          ),
+        ]),
+        ts.NodeFlags.Namespace |
+          ts.NodeFlags.ExportContext |
+          ts.NodeFlags.Ambient |
+          ts.NodeFlags.ContextFlags
+      ),
+    ]),
+    ts.NodeFlags.ExportContext |
+      ts.NodeFlags.GlobalAugmentation |
+      ts.NodeFlags.Ambient |
+      ts.NodeFlags.ContextFlags
+  );
+};
+
+/**
+ *
+ * @param {object} schemaDefinition
+ * @param {ts.InterfaceDeclaration} schemaDefinition.definition
+ * @param {object} schemaDefinition.schema
+ */
+const schemaDefinitionToPropertySignature = ({ schema }) => {
+  const { uid } = schema;
+
+  const interfaceTypeName = getSchemaInterfaceName(uid);
+
+  return factory.createPropertySignature(
+    undefined,
+    factory.createStringLiteral(uid, true),
+    undefined,
+    factory.createTypeReferenceNode(factory.createIdentifier(interfaceTypeName))
+  );
+};
+
+module.exports = { generateGlobalDefinition };

package/lib/generators/schemas/imports.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const { factory } = require('typescript');
+
+const imports = [];
+
+module.exports = {
+  getImports() {
+    return imports;
+  },
+
+  addImport(type) {
+    const hasType = imports.includes(type);
+
+    if (!hasType) {
+      imports.push(type);
+    }
+  },
+
+  generateImportDefinition() {
+    const formattedImports = imports.map(key =>
+      factory.createImportSpecifier(false, undefined, factory.createIdentifier(key))
+    );
+
+    return factory.createImportDeclaration(
+      undefined,
+      undefined,
+      factory.createImportClause(false, undefined, factory.createNamedImports(formattedImports)),
+      factory.createStringLiteral('@strapi/strapi'),
+      undefined
+    );
+  },
+};

package/lib/generators/schemas/index.js

@@ -0,0 +1,177 @@
+'use strict';
+
+const path = require('path');
+
+const ts = require('typescript');
+const { factory } = require('typescript');
+
+const fp = require('lodash/fp');
+const fse = require('fs-extra');
+const prettier = require('prettier');
+const chalk = require('chalk');
+const CLITable = require('cli-table3');
+
+const { generateImportDefinition } = require('./imports');
+const { generateSchemaDefinition } = require('./schema');
+const { generateGlobalDefinition } = require('./global');
+const {
+  getAllStrapiSchemas,
+  getSchemaInterfaceName,
+  getSchemaModelType,
+  getDefinitionAttributesCount,
+} = require('./utils');
+
+const DEFAULT_OUT_FILENAME = 'schemas.d.ts';
+
+/**
+ * Generate type definitions for Strapi schemas
+ *
+ * @param {object} options
+ * @param {Strapi} options.strapi
+ * @param {{ distDir: string; appDir: string; }} options.dirs
+ * @param {string} [options.outDir]
+ * @param {string} [options.file]
+ * @param {boolean} [options.verbose]
+ */
+const generateSchemasDefinitions = async (options = {}) => {
+  const { strapi, outDir = process.cwd(), file = DEFAULT_OUT_FILENAME, verbose = false } = options;
+
+  const schemas = getAllStrapiSchemas(strapi);
+
+  const schemasDefinitions = Object.values(schemas).map(schema => ({
+    schema,
+    definition: generateSchemaDefinition(schema),
+  }));
+
+  const formattedSchemasDefinitions = schemasDefinitions.reduce((acc, def) => {
+    acc.push(
+      // Definition
+      def.definition,
+
+      // Add a newline between each interface declaration
+      factory.createIdentifier('\n')
+    );
+
+    return acc;
+  }, []);
+
+  const allDefinitions = [
+    // Imports
+    generateImportDefinition(),
+
+    // Add a newline after the import statement
+    factory.createIdentifier('\n'),
+
+    // Schemas
+    ...formattedSchemasDefinitions,
+
+    // Global
+    generateGlobalDefinition(schemasDefinitions),
+  ];
+
+  const output = emitDefinitions(allDefinitions);
+  const formattedOutput = await format(output);
+
+  const definitionFilepath = await saveDefinitionToFileSystem(outDir, file, formattedOutput);
+
+  if (verbose) {
+    logDebugInformation(schemasDefinitions, { filepath: definitionFilepath });
+  }
+};
+
+const emitDefinitions = definitions => {
+  const nodeArray = factory.createNodeArray(definitions);
+
+  const sourceFile = ts.createSourceFile(
+    'placeholder.ts',
+    '',
+    ts.ScriptTarget.ESNext,
+    true,
+    ts.ScriptKind.TS
+  );
+
+  const printer = ts.createPrinter({ newLine: true, omitTrailingSemicolon: true });
+
+  return printer.printList(ts.ListFormat.MultiLine, nodeArray, sourceFile);
+};
+
+const saveDefinitionToFileSystem = async (dir, file, content) => {
+  const filepath = path.join(dir, file);
+
+  await fse.writeFile(filepath, content);
+
+  return filepath;
+};
+
+/**
+ * Format the given definitions.
+ * Uses the existing config if one is defined in the project.
+ *
+ * @param {string} content
+ * @returns {string}
+ */
+const format = async content => {
+  const configFile = await prettier.resolveConfigFile();
+  const config = configFile
+    ? await prettier.resolveConfig(configFile)
+    : // Default config
+      {
+        singleQuote: true,
+        useTabs: false,
+        tabWidth: 2,
+      };
+
+  Object.assign(config, { parser: 'typescript' });
+
+  return prettier.format(content, config);
+};
+
+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),
+  }));
+
+  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());
+
+  // Metrics
+  console.log(
+    chalk.greenBright(
+      `Generated ${definitions.length} type definition for your Strapi application's schemas.`
+    )
+  );
+
+  // Filepath
+  const relativePath = path.relative(process.cwd(), filepath);
+
+  console.log(
+    chalk.grey(`The definitions file has been generated here: ${chalk.bold(relativePath)}`)
+  );
+};
+
+module.exports = generateSchemasDefinitions;

package/lib/generators/schemas/schema.js

@@ -0,0 +1,87 @@
+'use strict';
+
+const ts = require('typescript');
+const { factory } = require('typescript');
+const { isEmpty } = require('lodash/fp');
+
+const { getSchemaExtendsTypeName, getSchemaInterfaceName, toTypeLiteral } = require('./utils');
+const attributeToPropertySignature = require('./attributes');
+const { addImport } = require('./imports');
+
+/**
+ * Generate an interface declaration for a given schema
+ *
+ * @param {object} schema
+ * @returns {ts.InterfaceDeclaration}
+ */
+const generateSchemaDefinition = schema => {
+  const { uid } = schema;
+
+  // Resolve the different interface names needed to declare the schema's interface
+  const interfaceName = getSchemaInterfaceName(uid);
+  const parentType = getSchemaExtendsTypeName(schema);
+
+  // Make sure the extended interface are imported
+  addImport(parentType);
+
+  // Properties whose values can be mapped to a literal type expression
+  const literalPropertiesDefinitions = ['info', 'options', 'pluginOptions']
+    // Ignore non-existent or empty declarations
+    .filter(key => !isEmpty(schema[key]))
+    // Generate literal definition for each property
+    .map(generatePropertyLiteralDefinitionFactory(schema));
+
+  // Generate the `attributes` literal type definition
+  const attributesProp = generateAttributePropertySignature(schema);
+
+  // Merge every schema's definition in a single list
+  const schemaProperties = [...literalPropertiesDefinitions, attributesProp];
+
+  // Generate the schema's interface declaration
+  const schemaType = factory.createInterfaceDeclaration(
+    undefined,
+    [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+    factory.createIdentifier(interfaceName),
+    undefined,
+    [
+      factory.createHeritageClause(ts.SyntaxKind.ExtendsKeyword, [
+        factory.createIdentifier(parentType),
+      ]),
+    ],
+    schemaProperties
+  );
+
+  return schemaType;
+};
+
+/**
+ * Generate a property signature for the schema's `attributes` field
+ *
+ * @param {object} schema
+ * @returns {ts.PropertySignature}
+ */
+const generateAttributePropertySignature = schema => {
+  const { attributes } = schema;
+
+  const properties = Object.entries(attributes).map(([attributeName, attribute]) => {
+    return attributeToPropertySignature(schema, attributeName, attribute);
+  });
+
+  return factory.createPropertySignature(
+    undefined,
+    factory.createIdentifier('attributes'),
+    undefined,
+    factory.createTypeLiteralNode(properties)
+  );
+};
+
+const generatePropertyLiteralDefinitionFactory = schema => key => {
+  return factory.createPropertySignature(
+    undefined,
+    factory.createIdentifier(key),
+    undefined,
+    toTypeLiteral(schema[key])
+  );
+};
+
+module.exports = { generateSchemaDefinition };

package/lib/generators/schemas/utils.js

@@ -0,0 +1,155 @@
+'use strict';
+
+const ts = require('typescript');
+const { factory } = require('typescript');
+const {
+  pipe,
+  replace,
+  camelCase,
+  upperFirst,
+  isUndefined,
+  isNull,
+  isString,
+  isNumber,
+  isArray,
+  isBoolean,
+  propEq,
+} = require('lodash/fp');
+
+/**
+ * Get all components and content-types in a Strapi application
+ *
+ * @param {Strapi} strapi
+ * @returns {object}
+ */
+const getAllStrapiSchemas = strapi => ({ ...strapi.contentTypes, ...strapi.components });
+
+/**
+ * Extract a valid interface name from a schema uid
+ *
+ * @param {string} uid
+ * @returns {string}
+ */
+const getSchemaInterfaceName = pipe(replace(/(:.)/, ' '), camelCase, upperFirst);
+
+/**
+ * Get the parent type name to extend based on the schema's nature
+ *
+ * @param {object} schema
+ * @returns {string}
+ */
+const getSchemaExtendsTypeName = schema => {
+  const base = getSchemaModelType(schema);
+
+  return upperFirst(base) + 'Schema';
+};
+
+const getSchemaModelType = schema => {
+  const { modelType, kind } = schema;
+
+  // Components
+  if (modelType === 'component') {
+    return 'component';
+  }
+
+  // Content-Types
+  else if (modelType === 'contentType') {
+    return kind;
+  }
+
+  return null;
+};
+
+/**
+ * Get a type node based on a type and its params
+ *
+ * @param {string} typeName
+ * @param {ts.TypeNode[]} [params]
+ * @returns
+ */
+const getTypeNode = (typeName, params = []) => {
+  return factory.createTypeReferenceNode(factory.createIdentifier(typeName), params);
+};
+
+/**
+ * Transform a regular JavaScript object or scalar value into a literal expression
+ * @param data
+ * @returns {ts.TypeNode}
+ */
+const toTypeLiteral = data => {
+  if (isUndefined(data)) {
+    return factory.createLiteralTypeNode(ts.SyntaxKind.UndefinedKeyword);
+  }
+
+  if (isNull(data)) {
+    return factory.createLiteralTypeNode(ts.SyntaxKind.NullKeyword);
+  }
+
+  if (isString(data)) {
+    return factory.createStringLiteral(data, true);
+  }
+
+  if (isNumber(data)) {
+    return factory.createNumericLiteral(data);
+  }
+
+  if (isBoolean(data)) {
+    return data ? factory.createTrue() : factory.createFalse();
+  }
+
+  if (isArray(data)) {
+    return factory.createTupleTypeNode(data.map(item => toTypeLiteral(item)));
+  }
+
+  if (typeof data !== 'object') {
+    throw new Error(`Cannot convert to object literal. Unknown type "${typeof data}"`);
+  }
+
+  const entries = Object.entries(data);
+
+  const props = entries.reduce((acc, [key, value]) => {
+    // Handle keys such as content-type-builder & co.
+    const identifier = key.includes('-')
+      ? factory.createStringLiteral(key, true)
+      : factory.createIdentifier(key);
+
+    return [
+      ...acc,
+      factory.createPropertyDeclaration(
+        undefined,
+        undefined,
+        identifier,
+        undefined,
+        toTypeLiteral(value)
+      ),
+    ];
+  }, []);
+
+  return factory.createTypeLiteralNode(props);
+};
+
+/**
+ * Get the number of attributes generated for a given schema definition
+ *
+ * @param {ts.TypeNode} definition
+ * @returns {number | null}
+ */
+const getDefinitionAttributesCount = definition => {
+  const attributesNode = definition.members.find(propEq('name.escapedText', 'attributes'));
+
+  if (!attributesNode) {
+    return null;
+  }
+
+  return attributesNode.type.members.length;
+};
+
+module.exports = {
+  getAllStrapiSchemas,
+  getSchemaInterfaceName,
+  getSchemaExtendsTypeName,
+  getSchemaModelType,
+  getDefinitionAttributesCount,
+  getTypeNode,
+  toTypeLiteral,
+};

package/lib/index.js

@@ -4,11 +4,13 @@ const compile = require('./compile');
 const compilers = require('./compilers');
 const admin = require('./admin');
 const utils = require('./utils');
+const generators = require('./generators');
 
 module.exports = {
   compile,
   compilers,
   admin,
+  generators,
 
   ...utils,
 };

package/lib/utils/resolve-outdir.js

@@ -8,7 +8,7 @@ const DEFAULT_TS_CONFIG_FILENAME = 'tsconfig.json';
  * Gets the outDir value from config file (tsconfig)
  * @param {string} dir
  * @param {string | undefined} configFilename
- * @returns {string | undefined}
+ * @returns {Promise<string | undefined>}
  */
 module.exports = async (dir, configFilename = DEFAULT_TS_CONFIG_FILENAME) => {
   return (await isUsingTypescript(dir))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/typescript-utils",
-  "version": "4.3.0-beta.1",
+  "version": "4.3.0-beta.2",
   "description": "Typescript support for Strapi",
   "keywords": [
     "strapi",
@@ -24,13 +24,16 @@
     "lib": "./lib"
   },
   "dependencies": {
+    "chalk": "4.1.2",
+    "cli-table3": "0.6.2",
     "fs-extra": "10.0.1",
     "lodash": "4.17.21",
+    "prettier": "2.7.1",
     "typescript": "4.6.2"
   },
   "engines": {
     "node": ">=12.22.0 <=16.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "9d6555398960c39159d66bb4eea3bcb0362e37e3"
+  "gitHead": "42aba356ad1b0751584d3b375e83baa4a2c18f65"
 }