@strapi/typescript-utils 0.0.0-next.f45143c5e2a8a9d85691d0abf79a3f42024a0c71 → 0.0.0-next.f7babb775ed9a7e18d8351cb7f74c63e016323c4

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

@@ -3,8 +3,8 @@
 const { factory } = 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');
 
 /**
@@ -26,7 +26,8 @@ const getAttributeType = (attributeName, attribute, uid) => {
 
   const [attributeType, typeParams] = mappers[attribute.type]({ uid, attribute, attributeName });
 
-  addImport(attributeType);
+  // Make sure the attribute namespace is imported
+  addImport(NAMESPACES.attribute);
 
   return getTypeNode(attributeType, typeParams);
 };
@@ -42,38 +43,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 +81,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)]
       )
@@ -102,38 +102,37 @@ 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);
 
     modifiers.push(
-      factory.createTypeReferenceNode(factory.createIdentifier('SetMinMax'), [
-        toTypeLiteral(minMaxProperties),
-      ])
+      factory.createTypeReferenceNode(
+        factory.createIdentifier(withAttributeNamespace('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),
-      ])
+      factory.createTypeReferenceNode(
+        factory.createIdentifier(withAttributeNamespace('SetMinMaxLength')),
+        [toTypeLiteral(minMaxProperties)]
+      )
     );
   }
 
   // Default
   if (!_.isNil(attribute.default)) {
-    addImport('DefaultTo');
-
     const defaultLiteral = toTypeLiteral(attribute.default);
 
     modifiers.push(
-      factory.createTypeReferenceNode(factory.createIdentifier('DefaultTo'), [defaultLiteral])
+      factory.createTypeReferenceNode(
+        factory.createIdentifier(withAttributeNamespace('DefaultTo')),
+        [defaultLiteral]
+      )
     );
   }
 

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/{schemas → common/models}/mappers.js

@@ -3,56 +3,56 @@
 const ts = require('typescript');
 const _ = require('lodash/fp');
 
-const { toTypeLiteral } = require('./utils');
+const { toTypeLiteral, withAttributeNamespace } = require('./utils');
 
 const { factory } = ts;
 
 module.exports = {
   string() {
-    return ['StringAttribute'];
+    return [withAttributeNamespace('String')];
   },
   text() {
-    return ['TextAttribute'];
+    return [withAttributeNamespace('Text')];
   },
   richtext() {
-    return ['RichTextAttribute'];
+    return [withAttributeNamespace('RichText')];
   },
   password() {
-    return ['PasswordAttribute'];
+    return [withAttributeNamespace('Password')];
   },
   email() {
-    return ['EmailAttribute'];
+    return [withAttributeNamespace('Email')];
   },
   date() {
-    return ['DateAttribute'];
+    return [withAttributeNamespace('Date')];
   },
   time() {
-    return ['TimeAttribute'];
+    return [withAttributeNamespace('Time')];
   },
   datetime() {
-    return ['DateTimeAttribute'];
+    return [withAttributeNamespace('DateTime')];
   },
   timestamp() {
-    return ['TimestampAttribute'];
+    return [withAttributeNamespace('Timestamp')];
   },
   integer() {
-    return ['IntegerAttribute'];
+    return [withAttributeNamespace('Integer')];
   },
   biginteger() {
-    return ['BigIntegerAttribute'];
+    return [withAttributeNamespace('BigInteger')];
   },
   float() {
-    return ['FloatAttribute'];
+    return [withAttributeNamespace('Float')];
   },
   decimal() {
-    return ['DecimalAttribute'];
+    return [withAttributeNamespace('Decimal')];
   },
   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'];
+      return [withAttributeNamespace('UID')];
     }
 
     const params = [];
@@ -74,21 +74,21 @@ module.exports = {
       params.push(toTypeLiteral(options));
     }
 
-    return ['UIDAttribute', params];
+    return [withAttributeNamespace('UID'), params];
   },
   enumeration({ attribute }) {
     const { enum: enumValues } = attribute;
 
-    return ['EnumerationAttribute', [toTypeLiteral(enumValues)]];
+    return [withAttributeNamespace('Enumeration'), [toTypeLiteral(enumValues)]];
   },
   boolean() {
-    return ['BooleanAttribute'];
+    return [withAttributeNamespace('Boolean')];
   },
   json() {
-    return ['JSONAttribute'];
+    return [withAttributeNamespace('JSON')];
   },
   media() {
-    return ['MediaAttribute'];
+    return [withAttributeNamespace('Media')];
   },
   relation({ uid, attribute }) {
     const { relation, target } = attribute;
@@ -97,13 +97,13 @@ module.exports = {
 
     if (isMorphRelation) {
       return [
-        'RelationAttribute',
+        withAttributeNamespace('Relation'),
         [factory.createStringLiteral(uid, true), factory.createStringLiteral(relation, true)],
       ];
     }
 
     return [
-      'RelationAttribute',
+      withAttributeNamespace('Relation'),
       [
         factory.createStringLiteral(uid, true),
         factory.createStringLiteral(relation, true),
@@ -119,13 +119,13 @@ module.exports = {
       params.push(factory.createTrue());
     }
 
-    return ['ComponentAttribute', params];
+    return [withAttributeNamespace('Component'), params];
   },
   dynamiczone({ attribute }) {
     const componentsParam = factory.createTupleTypeNode(
       attribute.components.map((component) => factory.createStringLiteral(component))
     );
 
-    return ['DynamicZoneAttribute', [componentsParam]];
+    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 Schema namespace is imported
+  addImport(NAMESPACES.schema);
 
   // 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
@@ -69,7 +74,6 @@ const generateSchemaDefinition = (schema) => {
 
   // Generate the schema's interface declaration
   const schemaType = factory.createInterfaceDeclaration(
-    undefined,
     [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
     factory.createIdentifier(interfaceName),
     undefined,

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 = {
+  schema: 'Schema',
+  attribute: 'Attribute',
+};
 
 /**
  * Extract a valid interface name from a schema uid
@@ -58,7 +55,11 @@ const getSchemaModelType = (schema) => {
 const getSchemaExtendsTypeName = (schema) => {
   const base = getSchemaModelType(schema);
 
-  return `${upperFirst(base)}Schema`;
+  if (base === null) {
+    return null;
+  }
+
+  return `${NAMESPACES.schema}.${upperFirst(base)}`;
 };
 
 /**
@@ -120,13 +121,7 @@ const toTypeLiteral = (data) => {
 
     return [
       ...acc,
-      factory.createPropertyDeclaration(
-        undefined,
-        undefined,
-        identifier,
-        undefined,
-        toTypeLiteral(value)
-      ),
+      factory.createPropertyDeclaration(undefined, identifier, undefined, toTypeLiteral(value)),
     ];
   }, []);
 
@@ -149,8 +144,26 @@ const getDefinitionAttributesCount = (definition) => {
   return attributesNode.type.members.length;
 };
 
+/**
+ * Add the attribute namespace before the typename
+ *
+ * @param {string} typeName
+ * @returns {string}
+ */
+const withAttributeNamespace = (typeName) => `${NAMESPACES.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,

package/lib/generators/components/index.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const { factory } = require('typescript');
+
+const { models } = require('../common');
+const { emitDefinitions, format, generateSharedExtensionDefinition } = require('../utils');
+
+/**
+ * Generate type definitions for Strapi Components
+ *
+ * @param {object} [options]
+ * @param {object} options.strapi
+ * @param {object} options.logger
+ * @param {string} options.pwd
+ */
+const generateComponentsDefinitions = async (options = {}) => {
+  const { strapi } = options;
+
+  const { components } = strapi;
+
+  const componentsDefinitions = Object.values(components).map((contentType) => ({
+    uid: contentType.uid,
+    definition: models.schema.generateSchemaDefinition(contentType),
+  }));
+
+  const formattedSchemasDefinitions = componentsDefinitions.reduce((acc, def) => {
+    acc.push(
+      // Definition
+      def.definition,
+
+      // Add a newline between each interface declaration
+      factory.createIdentifier('\n')
+    );
+
+    return acc;
+  }, []);
+
+  const allDefinitions = [
+    // Imports
+    ...models.imports.generateImportDefinition(),
+
+    // Add a newline after the import statement
+    factory.createIdentifier('\n'),
+
+    // Schemas
+    ...formattedSchemasDefinitions,
+
+    // Global
+    generateSharedExtensionDefinition('Components', componentsDefinitions),
+  ];
+
+  const output = emitDefinitions(allDefinitions);
+  const formattedOutput = await format(output);
+
+  return { output: formattedOutput, stats: {} };
+};
+
+module.exports = generateComponentsDefinitions;

package/lib/generators/constants.js

@@ -0,0 +1,6 @@
+'use strict';
+
+const TYPES_ROOT_DIR = 'types';
+const GENERATED_OUT_DIR = 'generated';
+
+module.exports = { GENERATED_OUT_DIR, TYPES_ROOT_DIR };

package/lib/generators/content-types/index.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const { factory } = require('typescript');
+
+const { models } = require('../common');
+const { emitDefinitions, format, generateSharedExtensionDefinition } = require('../utils');
+
+/**
+ * Generate type definitions for Strapi Content-Types
+ *
+ * @param {object} [options]
+ * @param {object} options.strapi
+ * @param {object} options.logger
+ * @param {string} options.pwd
+ */
+const generateContentTypesDefinitions = async (options = {}) => {
+  const { strapi } = options;
+
+  const { contentTypes } = strapi;
+
+  const contentTypesDefinitions = Object.values(contentTypes).map((contentType) => ({
+    uid: contentType.uid,
+    definition: models.schema.generateSchemaDefinition(contentType),
+  }));
+
+  const formattedSchemasDefinitions = contentTypesDefinitions.reduce((acc, def) => {
+    acc.push(
+      // Definition
+      def.definition,
+
+      // Add a newline between each interface declaration
+      factory.createIdentifier('\n')
+    );
+
+    return acc;
+  }, []);
+
+  const allDefinitions = [
+    // Imports
+    ...models.imports.generateImportDefinition(),
+
+    // Add a newline after the import statement
+    factory.createIdentifier('\n'),
+
+    // Schemas
+    ...formattedSchemasDefinitions,
+
+    // Global
+    generateSharedExtensionDefinition('ContentTypes', contentTypesDefinitions),
+  ];
+
+  const output = emitDefinitions(allDefinitions);
+  const formattedOutput = await format(output);
+
+  return { output: formattedOutput, stats: {} };
+};
+
+module.exports = generateContentTypesDefinitions;

package/lib/generators/index.js

@@ -1,7 +1,122 @@
 'use strict';
 
-const generateSchemasDefinitions = require('./schemas');
+const path = require('path');
+const chalk = require('chalk');
 
-module.exports = {
-  generateSchemasDefinitions,
+const { TYPES_ROOT_DIR, GENERATED_OUT_DIR } = require('./constants');
+const { saveDefinitionToFileSystem, createLogger, timer } = require('./utils');
+const generateContentTypesDefinitions = require('./content-types');
+const generateComponentsDefinitions = require('./components');
+
+const GENERATORS = {
+  contentTypes: generateContentTypesDefinitions,
+  components: generateComponentsDefinitions,
 };
+
+/**
+ * @typedef GenerateConfig
+ *
+ * @property {object} strapi
+ * @property {boolean} pwd
+ * @property {object} [artifacts]
+ * @property {boolean} [artifacts.contentTypes]
+ * @property {boolean} [artifacts.components]
+ * @property {boolean} [artifacts.services]
+ * @property {boolean} [artifacts.controllers]
+ * @property {boolean} [artifacts.policies]
+ * @property {boolean} [artifacts.middlewares]
+ * @property {object} [logger]
+ * @property {boolean} [logger.silent]
+ * @property {boolean} [logger.debug]
+ * @property {boolean} [logger.verbose]
+ */
+
+/**
+ * Generate types definitions based on the given configuration
+ *
+ * @param {GenerateConfig} [config]
+ */
+const generate = async (config = {}) => {
+  const { pwd, rootDir = TYPES_ROOT_DIR, strapi, artifacts = {}, logger: loggerConfig } = config;
+  const reports = {};
+  const logger = createLogger(loggerConfig);
+  const psTimer = timer().start();
+
+  const registryPwd = path.join(pwd, rootDir, GENERATED_OUT_DIR);
+  const generatorConfig = { strapi, pwd: registryPwd, logger };
+
+  const returnWithMessage = () => {
+    const nbWarnings = chalk.yellow(`${logger.warnings} warning(s)`);
+    const nbErrors = chalk.red(`${logger.errors} error(s)`);
+
+    const status = logger.errors > 0 ? chalk.red('errored') : chalk.green('completed successfully');
+
+    psTimer.end();
+
+    logger.info(`The task ${status} with ${nbWarnings} and ${nbErrors} in ${psTimer.duration}s.`);
+
+    return reports;
+  };
+
+  const enabledArtifacts = Object.keys(artifacts).filter((p) => artifacts[p] === true);
+
+  logger.info('Starting the type generation process');
+  logger.debug(`Enabled artifacts: ${enabledArtifacts.join(', ')}`);
+
+  for (const artifact of enabledArtifacts) {
+    const boldArtifact = chalk.bold(artifact); // used for log messages
+
+    logger.info(`Generating types for ${boldArtifact}`);
+
+    if (artifact in GENERATORS) {
+      const generator = GENERATORS[artifact];
+
+      try {
+        const artifactGenTimer = timer().start();
+
+        reports[artifact] = await generator(generatorConfig);
+
+        artifactGenTimer.end();
+
+        logger.debug(`Generated ${boldArtifact} in ${artifactGenTimer.duration}s`);
+      } catch (e) {
+        logger.error(
+          `Failed to generate types for ${boldArtifact}: ${e.message ?? e.toString()}. Exiting`
+        );
+        return returnWithMessage();
+      }
+    } else {
+      logger.warn(`The types generator for ${boldArtifact} is not implemented, skipping`);
+    }
+  }
+
+  for (const artifact of Object.keys(reports)) {
+    const boldArtifact = chalk.bold(artifact); // used for log messages
+
+    const artifactFsTimer = timer().start();
+
+    const report = reports[artifact];
+    const filename = `${artifact}.d.ts`;
+
+    try {
+      const outPath = await saveDefinitionToFileSystem(registryPwd, filename, report.output);
+      const relativeOutPath = path.relative(__dirname, outPath);
+
+      artifactFsTimer.end();
+
+      logger.info(`Saved ${boldArtifact} types in ${chalk.bold(relativeOutPath)}`);
+      logger.debug(`Saved ${boldArtifact} in ${artifactFsTimer.duration}s`);
+    } catch (e) {
+      logger.error(
+        `An error occurred while saving ${boldArtifact} types to the filesystem: ${
+          e.message ?? e.toString()
+        }. Exiting`
+      );
+      return returnWithMessage();
+    }
+  }
+
+  return returnWithMessage();
+};
+
+module.exports = { generate };