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

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

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)}`;
 };
 
 /**
@@ -143,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 };

package/lib/generators/utils.js

@@ -0,0 +1,211 @@
+'use strict';
+
+const ts = require('typescript');
+const prettier = require('prettier');
+const fse = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const assert = require('assert');
+
+const { factory } = ts;
+
+/**
+ * Aggregate the given TypeScript nodes into a single string
+ *
+ * @param {ts.Node[]} definitions
+ * @return {string}
+ */
+const emitDefinitions = (definitions) => {
+  const nodeArray = factory.createNodeArray(definitions);
+
+  const sourceFile = ts.createSourceFile(
+    'placeholder.ts',
+    '',
+    ts.ScriptTarget.ESNext,
+    true,
+    ts.ScriptKind.TS
+  );
+
+  const printer = ts.createPrinter({ omitTrailingSemicolon: true });
+
+  return printer.printList(ts.ListFormat.MultiLine, nodeArray, sourceFile);
+};
+
+/**
+ * Save the given string representation of TS nodes in a file
+ * If the given directory doesn't exist, it'll be created automatically
+ *
+ * @param {string} dir
+ * @param {string} file
+ * @param {string} content
+ *
+ * @return {Promise<string>} The path of the created file
+ */
+const saveDefinitionToFileSystem = async (dir, file, content) => {
+  const filepath = path.join(dir, file);
+
+  fse.ensureDirSync(dir);
+  await fse.writeFile(filepath, content);
+
+  return filepath;
+};
+
+/**
+ * Format the given definitions.
+ * Uses the existing config if one is defined in the project.
+ *
+ * @param {string} content
+ * @returns {Promise<string>}
+ */
+const format = async (content) => {
+  const configFile = await prettier.resolveConfigFile();
+  const config = configFile
+    ? await prettier.resolveConfig(configFile)
+    : // Default config
+      {
+        singleQuote: true,
+        useTabs: false,
+        tabWidth: 2,
+      };
+
+  Object.assign(config, { parser: 'typescript' });
+
+  return prettier.format(content, config);
+};
+
+/**
+ * Generate the extension block for a shared component from strapi/strapi
+ *
+ * @param {string} registry The registry to extend
+ * @param {Array<{ uid: string; definition: ts.TypeNode }>} definitions
+ * @returns {ts.ModuleDeclaration}
+ */
+const generateSharedExtensionDefinition = (registry, definitions) => {
+  const properties = definitions.map(({ uid, definition }) =>
+    factory.createPropertySignature(
+      undefined,
+      factory.createStringLiteral(uid, true),
+      undefined,
+      factory.createTypeReferenceNode(factory.createIdentifier(definition.name.escapedText))
+    )
+  );
+
+  return factory.createModuleDeclaration(
+    [factory.createModifier(ts.SyntaxKind.DeclareKeyword)],
+    factory.createStringLiteral('@strapi/strapi', true),
+    factory.createModuleBlock([
+      factory.createModuleDeclaration(
+        [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+        factory.createIdentifier('Shared'),
+        factory.createModuleBlock(
+          properties.length > 0
+            ? [
+                factory.createInterfaceDeclaration(
+                  [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+                  factory.createIdentifier(registry),
+                  undefined,
+                  undefined,
+                  properties
+                ),
+              ]
+            : []
+        )
+      ),
+    ]),
+    ts.NodeFlags.ExportContext
+  );
+};
+
+const createLogger = (options = {}) => {
+  const { silent = false, debug = false } = options;
+
+  const state = { errors: 0, warning: 0 };
+
+  return {
+    get warnings() {
+      return state.warning;
+    },
+
+    get errors() {
+      return state.errors;
+    },
+
+    debug(...args) {
+      if (silent || !debug) {
+        return;
+      }
+
+      console.log(chalk.cyan(`[DEBUG]\t[${new Date().toISOString()}] (Typegen)`), ...args);
+    },
+
+    info(...args) {
+      if (silent) {
+        return;
+      }
+
+      console.info(chalk.blue(`[INFO]\t[${new Date().toISOString()}] (Typegen)`), ...args);
+    },
+
+    warn(...args) {
+      state.warning += 1;
+
+      if (silent) {
+        return;
+      }
+
+      console.warn(chalk.yellow(`[WARN]\t[${new Date().toISOString()}] (Typegen)`), ...args);
+    },
+
+    error(...args) {
+      state.errors += 1;
+
+      if (silent) {
+        return;
+      }
+
+      console.error(chalk.red(`[ERROR]\t[${new Date().toISOString()}] (Typegen)`), ...args);
+    },
+  };
+};
+
+const timer = () => {
+  const state = {
+    start: null,
+    end: null,
+  };
+
+  return {
+    start() {
+      assert(state.start === null, 'The timer has already been started');
+      assert(state.end === null, 'The timer has already been ended');
+
+      state.start = Date.now();
+
+      return this;
+    },
+
+    end() {
+      assert(state.start !== null, 'The timer needs to be started before ending it');
+      assert(state.end === null, 'The timer has already been ended');
+
+      state.end = Date.now();
+
+      return this;
+    },
+
+    get duration() {
+      assert(state.start !== null, 'The timer has not been started');
+
+      return ((state.end ?? Date.now) - state.start) / 1000;
+    },
+  };
+};
+
+module.exports = {
+  emitDefinitions,
+  saveDefinitionToFileSystem,
+  format,
+  generateSharedExtensionDefinition,
+  createLogger,
+  timer,
+};