@strapi/typescript-utils 5.50.0 → 5.50.2

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

@@ -1,144 +0,0 @@
-'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/common/models/schema.js

@@ -1,93 +0,0 @@
-'use strict';
-
-const ts = require('typescript');
-const { factory } = require('typescript');
-const { isEmpty } = require('lodash/fp');
-
-const {
-  getSchemaExtendsTypeName,
-  getSchemaInterfaceName,
-  toTypeLiteral,
-  NAMESPACES,
-} = require('./utils');
-const attributeToPropertySignature = require('./attributes');
-const { addImport } = require('../imports');
-
-/**
- * Generate a property signature for the schema's `attributes` field
- *
- * @param {object} schema
- * @returns {ts.PropertySignature}
- */
-const generateAttributePropertySignature = (schema) => {
-  const { attributes } = schema;
-
-  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,
-    factory.createIdentifier('attributes'),
-    undefined,
-    factory.createTypeLiteralNode(properties)
-  );
-};
-
-const generatePropertyLiteralDefinitionFactory = (schema) => (key) => {
-  return factory.createPropertySignature(
-    undefined,
-    factory.createIdentifier(key),
-    undefined,
-    toTypeLiteral(schema[key])
-  );
-};
-
-/**
- * Generate an interface declaration for a given schema
- *
- * @param {object} schema
- * @returns {ts.InterfaceDeclaration}
- */
-const generateSchemaDefinition = (schema) => {
-  const { uid } = schema;
-
-  // Resolve the different interface names needed to declare the schema's interface
-  const interfaceName = getSchemaInterfaceName(uid);
-  const parentType = getSchemaExtendsTypeName(schema);
-
-  // Make sure the Struct namespace is imported
-  addImport(NAMESPACES.Struct);
-
-  // Properties whose values can be mapped to a literal type expression
-  const literalPropertiesDefinitions = ['collectionName', 'info', 'options', 'pluginOptions']
-    // Ignore non-existent or empty declarations
-    .filter((key) => !isEmpty(schema[key]))
-    // Generate literal definition for each property
-    .map(generatePropertyLiteralDefinitionFactory(schema));
-
-  // Generate the `attributes` literal type definition
-  const attributesProp = generateAttributePropertySignature(schema);
-
-  // Merge every schema's definition in a single list
-  const schemaProperties = [...literalPropertiesDefinitions, attributesProp];
-
-  // Generate the schema's interface declaration
-  const schemaType = factory.createInterfaceDeclaration(
-    [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
-    factory.createIdentifier(interfaceName),
-    undefined,
-    [
-      factory.createHeritageClause(ts.SyntaxKind.ExtendsKeyword, [
-        factory.createIdentifier(parentType),
-      ]),
-    ],
-    schemaProperties
-  );
-
-  return schemaType;
-};
-
-module.exports = { generateSchemaDefinition };

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

@@ -1,178 +0,0 @@
-'use strict';
-
-const ts = require('typescript');
-const { factory } = require('typescript');
-const {
-  pipe,
-  replace,
-  camelCase,
-  upperFirst,
-  isUndefined,
-  isNull,
-  isString,
-  isNumber,
-  isDate,
-  isArray,
-  isBoolean,
-  propEq,
-} = require('lodash/fp');
-
-const NAMESPACES = {
-  Struct: 'Struct',
-  Schema: 'Schema',
-};
-
-/**
- * Extract a valid interface name from a schema uid
- *
- * @param {string} uid
- * @returns {string}
- */
-const getSchemaInterfaceName = pipe(replace(/(:.)/, ' '), camelCase, upperFirst);
-
-const getSchemaModelType = (schema) => {
-  const { modelType, kind } = schema;
-
-  // Components
-  if (modelType === 'component') {
-    return 'component';
-  }
-
-  // Content-Types
-  if (modelType === 'contentType') {
-    return kind;
-  }
-
-  return null;
-};
-
-/**
- * Get the parent type name to extend based on the schema's nature
- *
- * @param {object} schema
- * @returns {string|null}
- */
-const getSchemaExtendsTypeName = (schema) => {
-  const base = getSchemaModelType(schema);
-
-  if (base === null) {
-    return null;
-  }
-
-  return `${NAMESPACES.Struct}.${upperFirst(base)}Schema`;
-};
-
-/**
- * Get a type node based on a type and its params
- *
- * @param {string} typeName
- * @param {ts.TypeNode[]} [params]
- * @returns
- */
-const getTypeNode = (typeName, params = []) => {
-  return factory.createTypeReferenceNode(factory.createIdentifier(typeName), params);
-};
-
-/**
- * Transform a regular JavaScript object or scalar value into a literal expression
- * @param data
- * @returns {ts.TypeNode}
- */
-const toTypeLiteral = (data) => {
-  if (isUndefined(data)) {
-    return factory.createLiteralTypeNode(ts.SyntaxKind.UndefinedKeyword);
-  }
-
-  if (isNull(data)) {
-    return factory.createLiteralTypeNode(ts.SyntaxKind.NullKeyword);
-  }
-
-  if (isString(data)) {
-    return factory.createStringLiteral(data, true);
-  }
-
-  if (isNumber(data)) {
-    return data < 0
-      ? factory.createPrefixUnaryExpression(
-          ts.SyntaxKind.MinusToken,
-          factory.createNumericLiteral(-data)
-        )
-      : factory.createNumericLiteral(data);
-  }
-
-  if (isBoolean(data)) {
-    return data ? factory.createTrue() : factory.createFalse();
-  }
-
-  if (isArray(data)) {
-    return factory.createTupleTypeNode(data.map((item) => toTypeLiteral(item)));
-  }
-
-  if (isDate(data)) {
-    return factory.createStringLiteral(data.toISOString());
-  }
-
-  if (typeof data !== 'object') {
-    throw new Error(`Cannot convert to object literal. Unknown type "${typeof 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.
-    const identifier = key.includes('-')
-      ? factory.createStringLiteral(key, true)
-      : factory.createIdentifier(key);
-
-    return [
-      ...acc,
-      factory.createPropertyDeclaration(undefined, identifier, undefined, toTypeLiteral(value)),
-    ];
-  }, []);
-
-  return factory.createTypeLiteralNode(props);
-};
-
-/**
- * Get the number of attributes generated for a given schema definition
- *
- * @param {ts.TypeNode} definition
- * @returns {number | null}
- */
-const getDefinitionAttributesCount = (definition) => {
-  const attributesNode = definition.members.find(propEq('name.escapedText', 'attributes'));
-
-  if (!attributesNode) {
-    return null;
-  }
-
-  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 = {
-  NAMESPACES,
-  withAttributeNamespace,
-  withSchemaNamespace,
-  getSchemaInterfaceName,
-  getSchemaExtendsTypeName,
-  getSchemaModelType,
-  getDefinitionAttributesCount,
-  getTypeNode,
-  toTypeLiteral,
-};

package/lib/generators/components/index.js

@@ -1,74 +0,0 @@
-'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

@@ -1,6 +0,0 @@
-'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

@@ -1,74 +0,0 @@
-'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,122 +0,0 @@
-'use strict';
-
-const path = require('path');
-const chalk = require('chalk');
-
-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 };