@strapi/typescript-utils 0.0.0-next.ff946d2c25a3e577b47132a357cac2932eb8e635 → 0.0.0-next.ffc36acb308febe288f1a31b62cbbb75b286585c

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
@@ -17,9 +22,11 @@ const { addImport } = require('./imports');
 const generateAttributePropertySignature = (schema) => {
   const { attributes } = schema;
 
-  const properties = Object.entries(attributes).map(([attributeName, attribute]) => {
-    return attributeToPropertySignature(schema, attributeName, attribute);
-  });
+  const properties = Object.entries(attributes)
+    .sort((a, b) => a[0].localeCompare(b[0]))
+    .map(([attributeName, attribute]) => {
+      return attributeToPropertySignature(schema, attributeName, attribute);
+    });
 
   return factory.createPropertySignature(
     undefined,
@@ -51,11 +58,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`;
 };
 
 /**
@@ -110,7 +111,7 @@ const toTypeLiteral = (data) => {
     throw new Error(`Cannot convert to object literal. Unknown type "${typeof data}"`);
   }
 
-  const entries = Object.entries(data);
+  const entries = Object.entries(data).sort((a, b) => a[0].localeCompare(b[0]));
 
   const props = entries.reduce((acc, [key, value]) => {
     // Handle keys such as content-type-builder & co.
@@ -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,

package/lib/generators/components/index.js

@@ -0,0 +1,74 @@
+'use strict';
+
+const { factory } = require('typescript');
+const { pipe, values, sortBy, map } = require('lodash/fp');
+
+const { models } = require('../common');
+const { emitDefinitions, format, generateSharedExtensionDefinition } = require('../utils');
+
+const NO_COMPONENT_PLACEHOLDER_COMMENT = `/*
+ * The app doesn't have any components yet.
+ */
+`;
+
+/**
+ * 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 = pipe(
+    values,
+    sortBy('uid'),
+    map((component) => ({
+      uid: component.uid,
+      definition: models.schema.generateSchemaDefinition(component),
+    }))
+  )(components);
+
+  options.logger.debug(`Found ${componentsDefinitions.length} components.`);
+
+  if (componentsDefinitions.length === 0) {
+    return { output: NO_COMPONENT_PLACEHOLDER_COMMENT, stats: {} };
+  }
+
+  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('ComponentSchemas', 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,74 @@
+'use strict';
+
+const { factory } = require('typescript');
+const { values, pipe, map, sortBy } = require('lodash/fp');
+
+const { models } = require('../common');
+const { emitDefinitions, format, generateSharedExtensionDefinition } = require('../utils');
+
+const NO_CONTENT_TYPE_PLACEHOLDER_COMMENT = `/*
+ * The app doesn't have any content-types yet.
+ */
+`;
+
+/**
+ * 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 = pipe(
+    values,
+    sortBy('uid'),
+    map((contentType) => ({
+      uid: contentType.uid,
+      definition: models.schema.generateSchemaDefinition(contentType),
+    }))
+  )(contentTypes);
+
+  options.logger.debug(`Found ${contentTypesDefinitions.length} content-types.`);
+
+  if (contentTypesDefinitions.length === 0) {
+    return { output: NO_CONTENT_TYPE_PLACEHOLDER_COMMENT, stats: {} };
+  }
+
+  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('ContentTypeSchemas', 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(process.cwd(), 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 };