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

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

@@ -6,7 +6,7 @@ const {
   addImport,
   generateImportDefinition,
   getImports,
-} = require('../../../generators/schemas/imports');
+} = require('../../../generators/common/imports');
 
 describe('Imports', () => {
   test('When first loaded, the list of imports should be empty', () => {
@@ -27,28 +27,30 @@ describe('Imports', () => {
   });
 
   test('Generate an import type definition containing the registered import', () => {
-    const def = generateImportDefinition();
+    const defs = generateImportDefinition();
 
-    expect(def.kind).toBe(ts.SyntaxKind.ImportDeclaration);
+    defs.forEach((def) => {
+      expect(def.kind).toBe(ts.SyntaxKind.ImportDeclaration);
 
-    // Module specifier
-    expect(def.moduleSpecifier.kind).toBe(ts.SyntaxKind.StringLiteral);
-    expect(def.moduleSpecifier.text).toBe('@strapi/strapi');
+      // Module specifier
+      expect(def.moduleSpecifier.kind).toBe(ts.SyntaxKind.StringLiteral);
+      expect(def.moduleSpecifier.text).toBe('@strapi/strapi');
 
-    // Import clause (should be named imports)
-    expect(def.importClause.kind).toBe(ts.SyntaxKind.ImportClause);
+      // Import clause (should be named imports)
+      expect(def.importClause.kind).toBe(ts.SyntaxKind.ImportClause);
 
-    const { elements } = def.importClause.namedBindings;
+      const { elements } = def.importClause.namedBindings;
 
-    expect(elements).toHaveLength(2);
+      expect(elements).toHaveLength(2);
 
-    // Import clauses
-    getImports().forEach((namedImport, index) => {
-      const element = elements[index];
+      // Import clauses
+      getImports().forEach((namedImport, index) => {
+        const element = elements[index];
 
-      expect(element.kind).toBe(ts.SyntaxKind.ImportSpecifier);
-      expect(element.name.kind).toBe(ts.SyntaxKind.Identifier);
-      expect(element.name.escapedText).toBe(namedImport);
+        expect(element.kind).toBe(ts.SyntaxKind.ImportSpecifier);
+        expect(element.name.kind).toBe(ts.SyntaxKind.Identifier);
+        expect(element.name.escapedText).toBe(namedImport);
+      });
     });
   });
 });

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

@@ -4,67 +4,15 @@ const ts = require('typescript');
 const { factory } = require('typescript');
 
 const {
-  getAllStrapiSchemas,
   getDefinitionAttributesCount,
   getSchemaExtendsTypeName,
   getSchemaInterfaceName,
   getSchemaModelType,
   getTypeNode,
   toTypeLiteral,
-} = require('../../../generators/schemas/utils');
+} = require('../../../generators/common/models/utils');
 
 describe('Utils', () => {
-  describe('Get All Strapi Schemas', () => {
-    test('Get both components and content types', () => {
-      const strapi = {
-        contentTypes: {
-          ctA: {},
-          ctB: {},
-        },
-        components: {
-          comp1: {},
-          comp2: {},
-          comp3: {},
-        },
-      };
-
-      const schemas = getAllStrapiSchemas(strapi);
-
-      expect(schemas).toMatchObject({ ctA: {}, ctB: {}, comp1: {}, comp2: {}, comp3: {} });
-    });
-
-    test('Get only components if there is no content type', () => {
-      const strapi = {
-        contentTypes: {},
-
-        components: {
-          comp1: {},
-          comp2: {},
-          comp3: {},
-        },
-      };
-
-      const schemas = getAllStrapiSchemas(strapi);
-
-      expect(schemas).toMatchObject({ comp1: {}, comp2: {}, comp3: {} });
-    });
-
-    test('Get only content types if there is no component', () => {
-      const strapi = {
-        contentTypes: {
-          ctA: {},
-          ctB: {},
-        },
-
-        components: {},
-      };
-
-      const schemas = getAllStrapiSchemas(strapi);
-
-      expect(schemas).toMatchObject({ ctA: {}, ctB: {} });
-    });
-  });
-
   describe('Get Definition Attributes Count', () => {
     const createMainNode = (members = []) => {
       return factory.createInterfaceDeclaration(
@@ -172,10 +120,10 @@ describe('Utils', () => {
 
   describe('Get Schema Extends Type Name', () => {
     test.each([
-      [{ modelType: 'component', kind: null }, 'ComponentSchema'],
-      [{ modelType: 'contentType', kind: 'singleType' }, 'SingleTypeSchema'],
-      [{ modelType: 'contentType', kind: 'collectionType' }, 'CollectionTypeSchema'],
-      [{ modelType: 'invalidType', kind: 'foo' }, 'Schema'],
+      [{ modelType: 'component', kind: null }, '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);
     });

package/lib/compile.js

@@ -3,12 +3,8 @@
 const compilers = require('./compilers');
 const getConfigPath = require('./utils/get-config-path');
 
-module.exports = async (srcDir, { watch = false, configOptions = {} } = {}) => {
-  // TODO: Use the Strapi debug logger instead or don't log at all
-  console.log(`Starting the compilation for TypeScript files in ${srcDir}`);
-
-  const compiler = watch ? compilers.watch : compilers.basic;
+module.exports = async (srcDir, { configOptions = {} } = {}) => {
   const configPath = getConfigPath(srcDir);
 
-  compiler.run(configPath, configOptions);
+  compilers.basic.run(configPath, configOptions);
 };

package/lib/compilers/basic.js

@@ -13,15 +13,23 @@ module.exports = {
    * @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: merge(options, configOptions.options),
+      options: compilerOptions,
     });
 
     const emitResults = program.emit();
@@ -30,12 +38,12 @@ module.exports = {
       ts.getPreEmitDiagnostics(program).concat(emitResults.diagnostics)
     );
 
-    if (diagnostics.length > 0) {
+    if (!ignoreDiagnostics && diagnostics.length > 0) {
       reportDiagnostics(diagnostics);
     }
 
-    // If the compilation failed, exit early
-    if (emitResults.emitSkipped) {
+    // If the compilation failed and diagnostics are not ignored, exit early
+    if (!ignoreDiagnostics && emitResults.emitSkipped) {
       process.exit(1);
     }
   },

package/lib/compilers/index.js

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

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

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

package/lib/generators/common/index.js

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

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

@@ -1,12 +1,14 @@
 'use strict';
 
-const { factory } = require('typescript');
+const ts = require('typescript');
 const _ = require('lodash/fp');
 
-const { addImport } = require('./imports');
-const { getTypeNode, toTypeLiteral } = require('./utils');
+const { addImport } = require('../imports');
+const { getTypeNode, toTypeLiteral, withAttributeNamespace, NAMESPACES } = require('./utils');
 const mappers = require('./mappers');
 
+const { factory } = ts;
+
 /**
  * Create the base type node for a given attribute
  *
@@ -26,7 +28,8 @@ const getAttributeType = (attributeName, attribute, uid) => {
 
   const [attributeType, typeParams] = mappers[attribute.type]({ uid, attribute, attributeName });
 
-  addImport(attributeType);
+  // Make sure the schema namespace is imported
+  addImport(NAMESPACES.Schema);
 
   return getTypeNode(attributeType, typeParams);
 };
@@ -42,38 +45,36 @@ const getAttributeModifiers = (attribute) => {
 
   // Required
   if (attribute.required) {
-    addImport('RequiredAttribute');
-
-    modifiers.push(factory.createTypeReferenceNode(factory.createIdentifier('RequiredAttribute')));
+    modifiers.push(
+      factory.createTypeReferenceNode(factory.createIdentifier(withAttributeNamespace('Required')))
+    );
   }
 
   // Private
   if (attribute.private) {
-    addImport('PrivateAttribute');
-
-    modifiers.push(factory.createTypeReferenceNode(factory.createIdentifier('PrivateAttribute')));
+    modifiers.push(
+      factory.createTypeReferenceNode(factory.createIdentifier(withAttributeNamespace('Private')))
+    );
   }
 
   // Unique
   if (attribute.unique) {
-    addImport('UniqueAttribute');
-
-    modifiers.push(factory.createTypeReferenceNode(factory.createIdentifier('UniqueAttribute')));
+    modifiers.push(
+      factory.createTypeReferenceNode(factory.createIdentifier(withAttributeNamespace('Unique')))
+    );
   }
 
   // Configurable
   if (attribute.configurable) {
-    addImport('ConfigurableAttribute');
-
     modifiers.push(
-      factory.createTypeReferenceNode(factory.createIdentifier('ConfigurableAttribute'))
+      factory.createTypeReferenceNode(
+        factory.createIdentifier(withAttributeNamespace('Configurable'))
+      )
     );
   }
 
   // Custom field
   if (attribute.customField) {
-    addImport('CustomField');
-
     const customFieldUid = factory.createStringLiteral(attribute.customField);
     const typeArguments = [customFieldUid];
 
@@ -82,17 +83,18 @@ const getAttributeModifiers = (attribute) => {
     }
 
     modifiers.push(
-      factory.createTypeReferenceNode(factory.createIdentifier('CustomField'), typeArguments)
+      factory.createTypeReferenceNode(
+        factory.createIdentifier(withAttributeNamespace('CustomField')),
+        typeArguments
+      )
     );
   }
 
   // Plugin Options
   if (!_.isEmpty(attribute.pluginOptions)) {
-    addImport('SetPluginOptions');
-
     modifiers.push(
       factory.createTypeReferenceNode(
-        factory.createIdentifier('SetPluginOptions'),
+        factory.createIdentifier(withAttributeNamespace('SetPluginOptions')),
         // Transform the pluginOptions object into an object literal expression
         [toTypeLiteral(attribute.pluginOptions)]
       )
@@ -100,40 +102,64 @@ const getAttributeModifiers = (attribute) => {
   }
 
   // Min / Max
-  // TODO: Always provide a second type argument for min/max (ie: resolve the attribute scalar type with a `GetAttributeType<${mappers[attribute][0]}>` (useful for biginter (string values)))
   if (!_.isNil(attribute.min) || !_.isNil(attribute.max)) {
-    addImport('SetMinMax');
-
     const minMaxProperties = _.pick(['min', 'max'], attribute);
+    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('SetMinMax'), [
-        toTypeLiteral(minMaxProperties),
-      ])
+      factory.createTypeReferenceNode(
+        factory.createIdentifier(withAttributeNamespace('SetMinMax')),
+        [toTypeLiteral(minMaxProperties), factory.createKeywordTypeNode(typeKeyword)]
+      )
     );
   }
 
   // Min length / Max length
   if (!_.isNil(attribute.minLength) || !_.isNil(attribute.maxLength)) {
-    addImport('SetMinMaxLength');
-
     const minMaxProperties = _.pick(['minLength', 'maxLength'], attribute);
 
     modifiers.push(
-      factory.createTypeReferenceNode(factory.createIdentifier('SetMinMaxLength'), [
-        toTypeLiteral(minMaxProperties),
-      ])
+      factory.createTypeReferenceNode(
+        factory.createIdentifier(withAttributeNamespace('SetMinMaxLength')),
+        [toTypeLiteral(minMaxProperties)]
+      )
     );
   }
 
-  // Default
-  if (!_.isNil(attribute.default)) {
-    addImport('DefaultTo');
-
+  // 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('DefaultTo'), [defaultLiteral])
+      factory.createTypeReferenceNode(
+        factory.createIdentifier(withAttributeNamespace('DefaultTo')),
+        [defaultLiteral]
+      )
     );
   }
 
@@ -169,6 +195,4 @@ const attributeToPropertySignature = (schema, attributeName, attribute) => {
 
 module.exports = attributeToPropertySignature;
 
-module.exports.mappers = mappers;
-module.exports.getAttributeType = getAttributeType;
-module.exports.getAttributeModifiers = getAttributeModifiers;
+Object.assign(module.exports, { mappers, getAttributeModifiers, getAttributeType });

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

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

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

@@ -0,0 +1,144 @@
+'use strict';
+
+const ts = require('typescript');
+const _ = require('lodash/fp');
+
+const { toTypeLiteral, withAttributeNamespace } = require('./utils');
+
+const { factory } = ts;
+
+module.exports = {
+  string() {
+    return [withAttributeNamespace('String')];
+  },
+  text() {
+    return [withAttributeNamespace('Text')];
+  },
+  richtext() {
+    return [withAttributeNamespace('RichText')];
+  },
+  password() {
+    return [withAttributeNamespace('Password')];
+  },
+  email() {
+    return [withAttributeNamespace('Email')];
+  },
+  date() {
+    return [withAttributeNamespace('Date')];
+  },
+  time() {
+    return [withAttributeNamespace('Time')];
+  },
+  datetime() {
+    return [withAttributeNamespace('DateTime')];
+  },
+  timestamp() {
+    return [withAttributeNamespace('Timestamp')];
+  },
+  integer() {
+    return [withAttributeNamespace('Integer')];
+  },
+  biginteger() {
+    return [withAttributeNamespace('BigInteger')];
+  },
+  float() {
+    return [withAttributeNamespace('Float')];
+  },
+  decimal() {
+    return [withAttributeNamespace('Decimal')];
+  },
+  uid({ attribute }) {
+    const { targetField, options } = attribute;
+
+    // If there are no params to compute, then return the attribute type alone
+    if (targetField === undefined && options === undefined) {
+      return [withAttributeNamespace('UID')];
+    }
+
+    const params = [];
+
+    // If the targetField property is defined, then reference it,
+    // otherwise, put `undefined` keyword type node as placeholder
+    const targetFieldParam = _.isUndefined(targetField)
+      ? factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword)
+      : factory.createStringLiteral(targetField);
+
+    params.push(targetFieldParam);
+
+    // If the options property is defined, transform it to
+    // a type literal node and add it to the params list
+    if (_.isObject(options)) {
+      params.push(toTypeLiteral(options));
+    }
+
+    return [withAttributeNamespace('UID'), params];
+  },
+  enumeration({ attribute }) {
+    const { enum: enumValues } = attribute;
+
+    return [withAttributeNamespace('Enumeration'), [toTypeLiteral(enumValues)]];
+  },
+  boolean() {
+    return [withAttributeNamespace('Boolean')];
+  },
+  json() {
+    return [withAttributeNamespace('JSON')];
+  },
+  blocks() {
+    return [withAttributeNamespace('Blocks')];
+  },
+  media({ attribute }) {
+    const { allowedTypes, multiple } = attribute;
+
+    const params = [];
+
+    const typesParam = allowedTypes
+      ? factory.createUnionTypeNode(
+          allowedTypes.map((allowedType) => factory.createStringLiteral(allowedType))
+        )
+      : factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword);
+
+    if (allowedTypes || multiple) {
+      params.push(typesParam);
+    }
+
+    if (multiple) {
+      params.push(factory.createTrue());
+    }
+
+    return [withAttributeNamespace('Media'), params];
+  },
+  relation({ attribute }) {
+    const { relation, target } = attribute;
+
+    const isMorphRelation = relation.toLowerCase().includes('morph');
+
+    if (isMorphRelation) {
+      return [withAttributeNamespace('Relation'), [factory.createStringLiteral(relation, true)]];
+    }
+
+    return [
+      withAttributeNamespace('Relation'),
+      [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());
+    } else {
+      params.push(factory.createFalse());
+    }
+
+    return [withAttributeNamespace('Component'), params];
+  },
+  dynamiczone({ attribute }) {
+    const componentsParam = factory.createTupleTypeNode(
+      attribute.components.map((component) => factory.createStringLiteral(component))
+    );
+
+    return [withAttributeNamespace('DynamicZone'), [componentsParam]];
+  },
+};

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

@@ -4,9 +4,14 @@ const ts = require('typescript');
 const { factory } = require('typescript');
 const { isEmpty } = require('lodash/fp');
 
-const { getSchemaExtendsTypeName, getSchemaInterfaceName, toTypeLiteral } = require('./utils');
+const {
+  getSchemaExtendsTypeName,
+  getSchemaInterfaceName,
+  toTypeLiteral,
+  NAMESPACES,
+} = require('./utils');
 const attributeToPropertySignature = require('./attributes');
-const { addImport } = require('./imports');
+const { addImport } = require('../imports');
 
 /**
  * Generate a property signature for the schema's `attributes` field
@@ -51,11 +56,11 @@ const generateSchemaDefinition = (schema) => {
   const interfaceName = getSchemaInterfaceName(uid);
   const parentType = getSchemaExtendsTypeName(schema);
 
-  // Make sure the extended interface are imported
-  addImport(parentType);
+  // Make sure the Struct namespace is imported
+  addImport(NAMESPACES.Struct);
 
   // Properties whose values can be mapped to a literal type expression
-  const literalPropertiesDefinitions = ['info', 'options', 'pluginOptions']
+  const literalPropertiesDefinitions = ['collectionName', 'info', 'options', 'pluginOptions']
     // Ignore non-existent or empty declarations
     .filter((key) => !isEmpty(schema[key]))
     // Generate literal definition for each property

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

@@ -17,13 +17,10 @@ const {
   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 });
+const NAMESPACES = {
+  Struct: 'Struct',
+  Schema: 'Schema',
+};
 
 /**
  * Extract a valid interface name from a schema uid
@@ -53,12 +50,16 @@ const getSchemaModelType = (schema) => {
  * Get the parent type name to extend based on the schema's nature
  *
  * @param {object} schema
- * @returns {string}
+ * @returns {string|null}
  */
 const getSchemaExtendsTypeName = (schema) => {
   const base = getSchemaModelType(schema);
 
-  return `${upperFirst(base)}Schema`;
+  if (base === null) {
+    return null;
+  }
+
+  return `${NAMESPACES.Struct}.${upperFirst(base)}Schema`;
 };
 
 /**
@@ -143,8 +144,26 @@ const getDefinitionAttributesCount = (definition) => {
   return attributesNode.type.members.length;
 };
 
+/**
+ * Add the Schema.Attribute namespace before the typename
+ *
+ * @param {string} typeName
+ * @returns {string}
+ */
+const withAttributeNamespace = (typeName) => `${NAMESPACES.Schema}.Attribute.${typeName}`;
+
+/**
+ * Add the schema namespace before the typename
+ *
+ * @param {string} typeName
+ * @returns {string}
+ */
+const withSchemaNamespace = (typeName) => `${NAMESPACES.schema}.${typeName}`;
+
 module.exports = {
-  getAllStrapiSchemas,
+  NAMESPACES,
+  withAttributeNamespace,
+  withSchemaNamespace,
   getSchemaInterfaceName,
   getSchemaExtendsTypeName,
   getSchemaModelType,