@strapi/typescript-utils 5.50.1 → 5.50.2

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

@@ -1,198 +0,0 @@
-'use strict';
-
-const ts = require('typescript');
-const _ = require('lodash/fp');
-
-const { addImport } = require('../imports');
-const { getTypeNode, toTypeLiteral, withAttributeNamespace, NAMESPACES } = require('./utils');
-const mappers = require('./mappers');
-
-const { factory } = ts;
-
-/**
- * Create the base type node for a given attribute
- *
- * @param {string} attributeName
- * @param {object} attribute
- * @param {string} uid
- * @returns {object}
- */
-const getAttributeType = (attributeName, attribute, uid) => {
-  if (!Object.keys(mappers).includes(attribute.type)) {
-    console.warn(
-      `"${attributeName}" attribute from "${uid}" has an invalid type: "${attribute.type}"`
-    );
-
-    return null;
-  }
-
-  const [attributeType, typeParams] = mappers[attribute.type]({ uid, attribute, attributeName });
-
-  // Make sure the schema namespace is imported
-  addImport(NAMESPACES.Schema);
-
-  return getTypeNode(attributeType, typeParams);
-};
-
-/**
- * Collect every modifier node from an attribute
- *
- * @param {object} attribute
- * @returns {object[]}
- */
-const getAttributeModifiers = (attribute) => {
-  const modifiers = [];
-
-  // Required
-  if (attribute.required) {
-    modifiers.push(
-      factory.createTypeReferenceNode(factory.createIdentifier(withAttributeNamespace('Required')))
-    );
-  }
-
-  // Private
-  if (attribute.private) {
-    modifiers.push(
-      factory.createTypeReferenceNode(factory.createIdentifier(withAttributeNamespace('Private')))
-    );
-  }
-
-  // Unique
-  if (attribute.unique) {
-    modifiers.push(
-      factory.createTypeReferenceNode(factory.createIdentifier(withAttributeNamespace('Unique')))
-    );
-  }
-
-  // Configurable
-  if (attribute.configurable) {
-    modifiers.push(
-      factory.createTypeReferenceNode(
-        factory.createIdentifier(withAttributeNamespace('Configurable'))
-      )
-    );
-  }
-
-  // Custom field
-  if (attribute.customField) {
-    const customFieldUid = factory.createStringLiteral(attribute.customField);
-    const typeArguments = [customFieldUid];
-
-    if (attribute.options) {
-      typeArguments.push(toTypeLiteral(attribute.options));
-    }
-
-    modifiers.push(
-      factory.createTypeReferenceNode(
-        factory.createIdentifier(withAttributeNamespace('CustomField')),
-        typeArguments
-      )
-    );
-  }
-
-  // Plugin Options
-  if (!_.isEmpty(attribute.pluginOptions)) {
-    modifiers.push(
-      factory.createTypeReferenceNode(
-        factory.createIdentifier(withAttributeNamespace('SetPluginOptions')),
-        // Transform the pluginOptions object into an object literal expression
-        [toTypeLiteral(attribute.pluginOptions)]
-      )
-    );
-  }
-
-  // Min / Max
-  if (!_.isNil(attribute.min) || !_.isNil(attribute.max)) {
-    const minMaxProperties = _.pick(['min', 'max'], attribute);
-    const { min, max } = minMaxProperties;
-
-    const typeofMin = typeof min;
-    const typeofMax = typeof max;
-
-    // Throws error if min/max exist but have different types to prevent unexpected behavior
-    if (min !== undefined && max !== undefined && typeofMin !== typeofMax) {
-      throw new Error('typeof min/max values mismatch');
-    }
-
-    let typeKeyword;
-
-    // use 'string'
-    if (typeofMin === 'string' || typeofMax === 'string') {
-      typeKeyword = ts.SyntaxKind.StringKeyword;
-    }
-    // use 'number'
-    else if (typeofMin === 'number' || typeofMax === 'number') {
-      typeKeyword = ts.SyntaxKind.NumberKeyword;
-    }
-    // invalid type
-    else {
-      throw new Error(
-        `Invalid data type for min/max options. Must be string, number or undefined, but found { min: ${min} (${typeofMin}), max: ${max} (${typeofMax}) }`
-      );
-    }
-
-    modifiers.push(
-      factory.createTypeReferenceNode(
-        factory.createIdentifier(withAttributeNamespace('SetMinMax')),
-        [toTypeLiteral(minMaxProperties), factory.createKeywordTypeNode(typeKeyword)]
-      )
-    );
-  }
-
-  // Min length / Max length
-  if (!_.isNil(attribute.minLength) || !_.isNil(attribute.maxLength)) {
-    const minMaxProperties = _.pick(['minLength', 'maxLength'], attribute);
-
-    modifiers.push(
-      factory.createTypeReferenceNode(
-        factory.createIdentifier(withAttributeNamespace('SetMinMaxLength')),
-        [toTypeLiteral(minMaxProperties)]
-      )
-    );
-  }
-
-  // Default (ignore if default is a function)
-  if (!_.isNil(attribute.default) && !_.isFunction(attribute.default)) {
-    const defaultLiteral = toTypeLiteral(attribute.default);
-
-    modifiers.push(
-      factory.createTypeReferenceNode(
-        factory.createIdentifier(withAttributeNamespace('DefaultTo')),
-        [defaultLiteral]
-      )
-    );
-  }
-
-  return modifiers;
-};
-
-/**
- * Generate a property signature node for a given attribute
- *
- * @param {object} schema
- * @param {string} attributeName
- * @param {object} attribute
- * @returns {object}
- */
-const attributeToPropertySignature = (schema, attributeName, attribute) => {
-  const baseType = getAttributeType(attributeName, attribute, schema.uid);
-
-  if (baseType === null) {
-    return null;
-  }
-
-  const modifiers = getAttributeModifiers(attribute);
-
-  const nodes = [baseType, ...modifiers];
-
-  return factory.createPropertySignature(
-    undefined,
-    factory.createIdentifier(attributeName),
-    undefined,
-    factory.createIntersectionTypeNode(nodes)
-  );
-};
-
-module.exports = attributeToPropertySignature;
-
-Object.assign(module.exports, { mappers, getAttributeModifiers, getAttributeType });

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

@@ -1,15 +0,0 @@
-'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/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 };