@strapi/typescript-utils 5.50.0 → 5.50.2

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

@@ -1,56 +0,0 @@
-'use strict';
-
-const ts = require('typescript');
-
-const {
-  addImport,
-  generateImportDefinition,
-  getImports,
-} = require('../../../generators/common/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 defs = generateImportDefinition();
-
-    defs.forEach((def) => {
-      expect(def.kind).toBe(ts.SyntaxKind.ImportDeclaration);
-
-      // Module specifier
-      expect(def.moduleSpecifier.kind).toBe(ts.SyntaxKind.StringLiteral);
-      expect(def.moduleSpecifier.text).toBe('@strapi/strapi');
-
-      // 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

@@ -1,314 +0,0 @@
-'use strict';
-
-const ts = require('typescript');
-const { factory } = require('typescript');
-
-const {
-  getDefinitionAttributesCount,
-  getSchemaExtendsTypeName,
-  getSchemaInterfaceName,
-  getSchemaModelType,
-  getTypeNode,
-  toTypeLiteral,
-} = require('../../../generators/common/models/utils');
-
-describe('Utils', () => {
-  describe('Get Definition Attributes Count', () => {
-    const createMainNode = (members = []) => {
-      return factory.createInterfaceDeclaration(
-        undefined,
-        factory.createIdentifier('Foo'),
-        undefined,
-        undefined,
-        members
-      );
-    };
-
-    const createPropertyDeclaration = (name, type) => {
-      return factory.createPropertyDeclaration(
-        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 }, 'Struct.ComponentSchema'],
-      [{ modelType: 'contentType', kind: 'singleType' }, 'Struct.SingleTypeSchema'],
-      [{ modelType: 'contentType', kind: 'collectionType' }, 'Struct.CollectionTypeSchema'],
-      [{ modelType: 'invalidType', kind: 'foo' }, null],
-    ])("Expect %p to generate %p as the base type for a schema's interface", (schema, expected) => {
-      expect(getSchemaExtendsTypeName(schema)).toBe(expected);
-    });
-  });
-
-  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 nodePositive = toTypeLiteral(42);
-      const nodeNegative = toTypeLiteral(-42);
-
-      expect(nodePositive.kind).toBe(ts.SyntaxKind.FirstLiteralToken);
-      expect(nodePositive.text).toBe('42');
-
-      expect(nodeNegative.kind).toBe(ts.SyntaxKind.PrefixUnaryExpression);
-      expect(nodeNegative.operator).toBe(ts.SyntaxKind.MinusToken);
-      expect(nodeNegative.operand.kind).toBe(ts.SyntaxKind.FirstLiteralToken);
-      expect(nodeNegative.operand.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('bar');
-      expect(objectNode.members[0].type.kind).toBe(ts.SyntaxKind.TrueKeyword);
-
-      expect(objectNode.members[1].kind).toBe(ts.SyntaxKind.PropertyDeclaration);
-      expect(objectNode.members[1].name.escapedText).toBe('foo');
-      expect(objectNode.members[1].type.kind).toBe(ts.SyntaxKind.StringLiteral);
-      expect(objectNode.members[1].type.text).toBe('bar');
-    });
-
-    test('Object', () => {
-      const node = toTypeLiteral({ foo: ['bar', true, 2], bar: null });
-
-      expect(node.kind).toBe(ts.SyntaxKind.TypeLiteral);
-      expect(node.members).toHaveLength(2);
-
-      const [barMember, fooMember] = node.members;
-
-      expect(barMember.kind).toBe(ts.SyntaxKind.PropertyDeclaration);
-      expect(barMember.name.escapedText).toBe('bar');
-      expect(barMember.type.kind).toBe(ts.SyntaxKind.LiteralType);
-      expect(barMember.type.literal).toBe(ts.SyntaxKind.NullKeyword);
-
-      expect(fooMember.kind).toBe(ts.SyntaxKind.PropertyDeclaration);
-      expect(fooMember.name.escapedText).toBe('foo');
-      expect(fooMember.type.kind).toBe(ts.SyntaxKind.TupleType);
-      expect(fooMember.type.elements).toHaveLength(3);
-      expect(fooMember.type.elements[0].kind).toBe(ts.SyntaxKind.StringLiteral);
-      expect(fooMember.type.elements[1].kind).toBe(ts.SyntaxKind.TrueKeyword);
-      expect(fooMember.type.elements[2].kind).toBe(ts.SyntaxKind.FirstLiteralToken);
-    });
-
-    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 [fooBar, fooDashBar] = node.members;
-
-      expect(fooBar.kind).toBe(ts.SyntaxKind.PropertyDeclaration);
-      expect(fooBar.name.kind).toBe(ts.SyntaxKind.Identifier);
-      expect(fooBar.name.escapedText).toBe('foo');
-      expect(fooBar.type.kind).toBe(ts.SyntaxKind.StringLiteral);
-      expect(fooBar.type.text).toBe('bar');
-
-      expect(fooDashBar.kind).toBe(ts.SyntaxKind.PropertyDeclaration);
-      expect(fooDashBar.name.kind).toBe(ts.SyntaxKind.StringLiteral);
-      expect(fooDashBar.name.text).toBe('foo-bar');
-      expect(fooDashBar.type.kind).toBe(ts.SyntaxKind.StringLiteral);
-      expect(fooDashBar.type.text).toBe('foobar');
-    });
-
-    test('Invalid data type supplied (function)', () => {
-      expect(() => toTypeLiteral(() => {})).toThrowError(
-        'Cannot convert to object literal. Unknown type "function"'
-      );
-    });
-  });
-});

package/lib/compile.js

@@ -1,10 +0,0 @@
-'use strict';
-
-const compilers = require('./compilers');
-const getConfigPath = require('./utils/get-config-path');
-
-module.exports = async (srcDir, { configOptions = {} } = {}) => {
-  const configPath = getConfigPath(srcDir);
-
-  compilers.basic.run(configPath, configOptions);
-};

package/lib/compilers/basic.js

@@ -1,50 +0,0 @@
-'use strict';
-
-const ts = require('typescript');
-const { merge } = require('lodash');
-
-const reportDiagnostics = require('../utils/report-diagnostics');
-const resolveConfigOptions = require('../utils/resolve-config-options');
-
-module.exports = {
-  /**
-   * Default TS -> JS Compilation for Strapi
-   * @param {string} tsConfigPath
-   * @param {Object} configOptions
-   * @param {Array.<string>} configOptions.fileNames
-   * @param {Object} configOptions.options
-   * @param {boolean} configOptions.ignoreDiagnostics
-   */
-  run(tsConfigPath, configOptions = {}) {
-    const { ignoreDiagnostics = false } = configOptions;
-    // Parse the tsconfig.json file & resolve the configuration options
-    const { fileNames, options, projectReferences } = resolveConfigOptions(tsConfigPath);
-
-    const compilerOptions = merge(options, configOptions.options);
-
-    if (ignoreDiagnostics) {
-      Object.assign(compilerOptions, { noEmit: false, noEmitOnError: false });
-    }
-
-    const program = ts.createProgram({
-      rootNames: configOptions.fileNames ? configOptions.fileNames : fileNames,
-      projectReferences,
-      options: compilerOptions,
-    });
-
-    const emitResults = program.emit();
-
-    const diagnostics = ts.sortAndDeduplicateDiagnostics(
-      ts.getPreEmitDiagnostics(program).concat(emitResults.diagnostics)
-    );
-
-    if (!ignoreDiagnostics && diagnostics.length > 0) {
-      reportDiagnostics(diagnostics);
-    }
-
-    // If the compilation failed and diagnostics are not ignored, exit early
-    if (!ignoreDiagnostics && emitResults.emitSkipped) {
-      throw new Error('TypeScript compilation failed');
-    }
-  },
-};

package/lib/compilers/index.js

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

package/lib/generators/common/imports.js

@@ -1,34 +0,0 @@
-'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
-      .sort()
-      .map((key) => factory.createImportSpecifier(false, undefined, factory.createIdentifier(key)));
-
-    return [
-      factory.createImportDeclaration(
-        undefined,
-        factory.createImportClause(true, undefined, factory.createNamedImports(formattedImports)),
-        factory.createStringLiteral('@strapi/strapi'),
-        undefined
-      ),
-    ];
-  },
-};

package/lib/generators/common/index.js

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

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

@@ -1,198 +0,0 @@
-'use strict';
-
-const ts = require('typescript');
-const _ = require('lodash/fp');
-
-const { addImport } = require('../imports');
-const { getTypeNode, toTypeLiteral, withAttributeNamespace, NAMESPACES } = require('./utils');
-const mappers = require('./mappers');
-
-const { factory } = ts;
-
-/**
- * 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 });
-
-  // Make sure the schema namespace is imported
-  addImport(NAMESPACES.Schema);
-
-  return getTypeNode(attributeType, typeParams);
-};
-
-/**
- * Collect every modifier node from an attribute
- *
- * @param {object} attribute
- * @returns {object[]}
- */
-const getAttributeModifiers = (attribute) => {
-  const modifiers = [];
-
-  // Required
-  if (attribute.required) {
-    modifiers.push(
-      factory.createTypeReferenceNode(factory.createIdentifier(withAttributeNamespace('Required')))
-    );
-  }
-
-  // Private
-  if (attribute.private) {
-    modifiers.push(
-      factory.createTypeReferenceNode(factory.createIdentifier(withAttributeNamespace('Private')))
-    );
-  }
-
-  // Unique
-  if (attribute.unique) {
-    modifiers.push(
-      factory.createTypeReferenceNode(factory.createIdentifier(withAttributeNamespace('Unique')))
-    );
-  }
-
-  // Configurable
-  if (attribute.configurable) {
-    modifiers.push(
-      factory.createTypeReferenceNode(
-        factory.createIdentifier(withAttributeNamespace('Configurable'))
-      )
-    );
-  }
-
-  // Custom field
-  if (attribute.customField) {
-    const customFieldUid = factory.createStringLiteral(attribute.customField);
-    const typeArguments = [customFieldUid];
-
-    if (attribute.options) {
-      typeArguments.push(toTypeLiteral(attribute.options));
-    }
-
-    modifiers.push(
-      factory.createTypeReferenceNode(
-        factory.createIdentifier(withAttributeNamespace('CustomField')),
-        typeArguments
-      )
-    );
-  }
-
-  // Plugin Options
-  if (!_.isEmpty(attribute.pluginOptions)) {
-    modifiers.push(
-      factory.createTypeReferenceNode(
-        factory.createIdentifier(withAttributeNamespace('SetPluginOptions')),
-        // Transform the pluginOptions object into an object literal expression
-        [toTypeLiteral(attribute.pluginOptions)]
-      )
-    );
-  }
-
-  // Min / Max
-  if (!_.isNil(attribute.min) || !_.isNil(attribute.max)) {
-    const minMaxProperties = _.pick(['min', 'max'], attribute);
-    const { min, max } = minMaxProperties;
-
-    const typeofMin = typeof min;
-    const typeofMax = typeof max;
-
-    // Throws error if min/max exist but have different types to prevent unexpected behavior
-    if (min !== undefined && max !== undefined && typeofMin !== typeofMax) {
-      throw new Error('typeof min/max values mismatch');
-    }
-
-    let typeKeyword;
-
-    // use 'string'
-    if (typeofMin === 'string' || typeofMax === 'string') {
-      typeKeyword = ts.SyntaxKind.StringKeyword;
-    }
-    // use 'number'
-    else if (typeofMin === 'number' || typeofMax === 'number') {
-      typeKeyword = ts.SyntaxKind.NumberKeyword;
-    }
-    // invalid type
-    else {
-      throw new Error(
-        `Invalid data type for min/max options. Must be string, number or undefined, but found { min: ${min} (${typeofMin}), max: ${max} (${typeofMax}) }`
-      );
-    }
-
-    modifiers.push(
-      factory.createTypeReferenceNode(
-        factory.createIdentifier(withAttributeNamespace('SetMinMax')),
-        [toTypeLiteral(minMaxProperties), factory.createKeywordTypeNode(typeKeyword)]
-      )
-    );
-  }
-
-  // Min length / Max length
-  if (!_.isNil(attribute.minLength) || !_.isNil(attribute.maxLength)) {
-    const minMaxProperties = _.pick(['minLength', 'maxLength'], attribute);
-
-    modifiers.push(
-      factory.createTypeReferenceNode(
-        factory.createIdentifier(withAttributeNamespace('SetMinMaxLength')),
-        [toTypeLiteral(minMaxProperties)]
-      )
-    );
-  }
-
-  // Default (ignore if default is a function)
-  if (!_.isNil(attribute.default) && !_.isFunction(attribute.default)) {
-    const defaultLiteral = toTypeLiteral(attribute.default);
-
-    modifiers.push(
-      factory.createTypeReferenceNode(
-        factory.createIdentifier(withAttributeNamespace('DefaultTo')),
-        [defaultLiteral]
-      )
-    );
-  }
-
-  return modifiers;
-};
-
-/**
- * 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(attribute);
-
-  const nodes = [baseType, ...modifiers];
-
-  return factory.createPropertySignature(
-    undefined,
-    factory.createIdentifier(attributeName),
-    undefined,
-    factory.createIntersectionTypeNode(nodes)
-  );
-};
-
-module.exports = attributeToPropertySignature;
-
-Object.assign(module.exports, { mappers, getAttributeModifiers, getAttributeType });

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

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