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

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 };

package/lib/generators/utils.js

@@ -0,0 +1,216 @@
+'use strict';
+
+const path = require('path');
+const assert = require('assert');
+const ts = require('typescript');
+const fse = require('fs-extra');
+const chalk = require('chalk');
+
+const { factory } = ts;
+
+const MODULE_DECLARATION = '@strapi/strapi';
+const PUBLIC_NAMESPACE = 'Public';
+
+/**
+ * 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) => {
+  // eslint-disable-next-line node/no-unsupported-features/es-syntax
+  const prettier = await import('prettier'); // ESM-only
+
+  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(MODULE_DECLARATION, true),
+    factory.createModuleBlock([
+      factory.createModuleDeclaration(
+        [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+        factory.createIdentifier(PUBLIC_NAMESPACE),
+        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,
+};

package/lib/index.js

@@ -2,15 +2,12 @@
 
 const compile = require('./compile');
 const compilers = require('./compilers');
-const admin = require('./admin');
 const utils = require('./utils');
 const generators = require('./generators');
 
 module.exports = {
   compile,
   compilers,
-  admin,
   generators,
-
   ...utils,
 };

package/lib/utils/index.js

@@ -7,6 +7,7 @@ const reportDiagnostics = require('./report-diagnostics');
 const resolveConfigOptions = require('./resolve-config-options');
 const formatHost = require('./format-host');
 const resolveOutDir = require('./resolve-outdir');
+const resolveOutDirSync = require('./resolve-outdir-sync');
 
 module.exports = {
   isUsingTypeScript,
@@ -16,4 +17,5 @@ module.exports = {
   resolveConfigOptions,
   formatHost,
   resolveOutDir,
+  resolveOutDirSync,
 };

package/lib/utils/resolve-outdir-sync.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const path = require('path');
+const resolveConfigOptions = require('./resolve-config-options');
+const isUsingTypescriptSync = require('./is-using-typescript-sync');
+
+const DEFAULT_TS_CONFIG_FILENAME = 'tsconfig.json';
+/**
+ * Gets the outDir value from config file (tsconfig)
+ * @param {string} dir
+ * @param {string | undefined} configFilename
+ * @returns {string | undefined}
+ */
+module.exports = (dir, configFilename = DEFAULT_TS_CONFIG_FILENAME) => {
+  return isUsingTypescriptSync(dir)
+    ? resolveConfigOptions(path.join(dir, configFilename)).options.outDir
+    : undefined;
+};

package/package.json

@@ -1,11 +1,16 @@
 {
   "name": "@strapi/typescript-utils",
-  "version": "0.0.0-next.e9bb5ccdc459f4c6b6717a2d5d86359b7a47d47d",
+  "version": "0.0.0-next.ec9b1b708d4d319f2b8b39d9397bd752d250d541",
   "description": "Typescript support for Strapi",
   "keywords": [
     "strapi",
     "generators"
   ],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/strapi/strapi.git",
+    "directory": "packages/utils/typescript"
+  },
   "license": "SEE LICENSE IN LICENSE",
   "author": {
     "name": "Strapi Solutions SAS",
@@ -31,15 +36,18 @@
   },
   "dependencies": {
     "chalk": "4.1.2",
-    "cli-table3": "0.6.2",
-    "fs-extra": "10.0.1",
+    "cli-table3": "0.6.5",
+    "fs-extra": "11.2.0",
     "lodash": "4.17.21",
-    "prettier": "2.8.4",
-    "typescript": "5.0.4"
+    "prettier": "3.3.3",
+    "typescript": "5.3.2"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "11.0.4"
   },
   "engines": {
-    "node": ">=14.19.1 <=18.x.x",
+    "node": ">=18.0.0 <=22.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "e9bb5ccdc459f4c6b6717a2d5d86359b7a47d47d"
+  "gitHead": "ec9b1b708d4d319f2b8b39d9397bd752d250d541"
 }