@strapi/typescript-utils 4.2.0-beta.3 → 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/admin/create-tsconfig-file.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs-extra');
+
+module.exports = async dest => {
+  const tsConfig = {
+    compilerOptions: {
+      lib: ['es2019', 'es2020.promise', 'es2020.bigint', 'es2020.string', 'DOM'],
+      noImplicitAny: false,
+      module: 'es2020',
+      target: 'es5',
+      jsx: 'react',
+      allowJs: true,
+      strict: true,
+      moduleResolution: 'node',
+      skipLibCheck: true,
+      esModuleInterop: true,
+      allowSyntheticDefaultImports: true,
+      resolveJsonModule: true,
+      noEmit: false,
+      incremental: true,
+    },
+    include: ['../../../src/admin/*', '../../../src/**/**/admin/src/*'],
+    exclude: ['node_modules', '**/*.test.js', '*.js'],
+  };
+
+  const filePath = path.join(dest, 'admin', 'src', 'tsconfig.json');
+
+  try {
+    await fs.ensureFile(filePath);
+
+    await fs.writeJSON(filePath, tsConfig, { spaces: 2 });
+  } catch (err) {
+    console.log(err);
+  }
+};

package/lib/admin/index.js

@@ -0,0 +1,5 @@
+'use strict';
+
+const createTSConfigFile = require('./create-tsconfig-file');
+
+module.exports = { createTSConfigFile };

package/lib/generators/index.js

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