@strapi/strapi 4.11.0 → 4.11.1-beta.1

package/lib/commands/actions/develop/action.js

@@ -121,13 +121,12 @@ const workerProcess = async ({ appDir, distDir, watchAdmin, polling, isTSProject
   const shouldGenerateTypeScriptTypes = strapiInstance.config.get('typescript.autogenerate', false);
 
   if (shouldGenerateTypeScriptTypes) {
-    // This is run in an uncaught promise on purpose so that it doesn't block Strapi startup
-    // NOTE: We should probably add some configuration options to manage the file structure output or the verbosity level
-    tsUtils.generators.generateSchemasDefinitions({
+    await tsUtils.generators.generate({
       strapi: strapiInstance,
-      outDir: appDir,
-      verbose: false,
-      silent: true,
+      pwd: appDir,
+      rootDir: undefined,
+      logger: { silent: true, debug: false },
+      artifacts: { contentTypes: true, components: true },
     });
   }
 

package/lib/commands/actions/ts/generate-types/action.js

@@ -4,22 +4,25 @@ const tsUtils = require('@strapi/typescript-utils');
 
 const strapi = require('../../../../index');
 
-module.exports = async ({ outDir, file, verbose, silent }) => {
-  if (verbose && silent) {
-    console.error('You cannot enable verbose and silent flags at the same time, exiting...');
+module.exports = async ({ debug, silent, verbose, outDir }) => {
+  if ((debug || verbose) && silent) {
+    console.error('Flags conflict: both silent and debug mode are enabled, exiting...');
     process.exit(1);
   }
 
   const appContext = await strapi.compile();
   const app = await strapi(appContext).register();
 
-  await tsUtils.generators.generateSchemasDefinitions({
+  await tsUtils.generators.generate({
     strapi: app,
-    outDir: outDir || appContext.appDir,
-    file,
-    dirs: appContext,
-    verbose,
-    silent,
+    pwd: appContext.appDir,
+    rootDir: outDir ?? undefined,
+    logger: {
+      silent,
+      // TODO V5: verbose is deprecated and should be removed
+      debug: debug || verbose,
+    },
+    artifacts: { contentTypes: true, components: true },
   });
 
   app.destroy();

package/lib/commands/actions/ts/generate-types/command.js

@@ -10,12 +10,12 @@ module.exports = ({ command }) => {
   command
     .command('ts:generate-types')
     .description(`Generate TypeScript typings for your schemas`)
+    .option('--verbose', `[DEPRECATED] The verbose option has been replaced by debug`, false)
+    .option('-d, --debug', `Run the generation with debug messages`, false)
+    .option('-s, --silent', `Run the generation silently, without any output`, false)
     .option(
       '-o, --out-dir <outDir>',
-      'Specify a relative directory in which the schemas definitions will be generated'
+      'Specify a relative root directory in which the definitions will be generated. Changing this value might break types exposed by Strapi that relies on generated types.'
     )
-    .option('-f, --file <file>', 'Specify a filename to store the schemas definitions')
-    .option('--verbose', `Display more information about the types generation`, false)
-    .option('-s, --silent', `Run the generation silently, without any output`, false)
     .action(getLocalScript('ts/generate-types'));
 };

package/lib/factories.d.ts

@@ -0,0 +1,21 @@
+import type { Common, CoreApi, Strapi } from '@strapi/strapi';
+
+type WithStrapiCallback<T> = <S extends { strapi: Strapi }>(params: S) => T;
+
+export declare function createCoreRouter<T extends Common.UID.ContentType>(
+  uid: T,
+  cfg?: CoreApi.Router.RouterConfig<T>
+): () => CoreApi.Router.Router;
+
+export declare function createCoreController<
+  T extends Common.UID.ContentType,
+  S extends Partial<CoreApi.Controller.Extendable<T>>
+>(
+  uid: T,
+  config?: WithStrapiCallback<S> | S
+): () => Required<S & CoreApi.Controller.ContentType<T>>;
+
+export declare function createCoreService<
+  T extends Common.UID.ContentType,
+  S extends Partial<CoreApi.Service.Extendable<T>>
+>(uid: T, config?: WithStrapiCallback<S> | S): () => Required<S & CoreApi.Service.ContentType<T>>;

package/lib/global.d.ts

@@ -1,51 +1,7 @@
 import type { Strapi as StrapiInterface } from './types/core';
-import type {
-  CollectionTypeSchema,
-  SingleTypeSchema,
-  ComponentSchema,
-  ContentTypeSchema,
-} from './types/core/schemas';
-import type { KeysBy } from './types/utils';
 
 declare global {
   namespace Strapi {
-    /**
-     * Map of UID / schemas used as a schemas database for other types.
-     * It must be extended by the user application or plugins.
-     *
-     * @example
-     * ```ts
-     * declare global {
-     *   namespace Strapi {
-     *     interface Schemas {
-     *       'xxx::xxx.uid: ContentTypeSchema | ComponentSchema;
-     *     }
-     *   }
-     * }
-     * ```
-     */
-    interface Schemas {}
-
-    /**
-     * Literal union type of every content type registered in Strapi.Schemas
-     */
-    type ContentTypeUIDs = KeysBy<Schemas, ContentTypeSchema>;
-
-    /**
-     * Literal union type of every collection type registered in Strapi.Schemas
-     */
-    type CollectionTypeUIDs = KeysBy<Schemas, CollectionTypeSchema>;
-
-    /**
-     * Literal union type of every single type registered in Strapi.Schemas
-     */
-    type SingleTypeUIDs = KeysBy<Schemas, SingleTypeSchema>;
-
-    /**
-     * Literal union type of every component registered in Strapi.Schemas
-     */
-    type ComponentUIDs = KeysBy<Schemas, ComponentSchema>;
-
     /**
      * Global shorthand to access the `StrapiInterface` type
      */

package/lib/index.d.ts

@@ -1,5 +1,6 @@
 import './global';
 
 export * from './types';
+export * as factories from './factories';
 
-export default function (opts): Strapi;
+export default function (opts): Strapi.Strapi;

package/lib/types/core/attributes/base.d.ts

@@ -1,9 +1,7 @@
-import { GetAttributeValue } from './utils';
-
 /**
  * List of all the Strapi attribute types
  */
-export type AttributeType =
+export type Kind =
   | 'string'
   | 'text'
   | 'richtext'
@@ -29,11 +27,11 @@ export type AttributeType =
 /**
  * Most basic shape of a schema attribute
  */
-export interface Attribute<T extends AttributeType = AttributeType> {
+export interface Attribute<TKind extends Kind = Kind> {
   /**
    * Type of the attribute
    */
-  type: T;
+  type: TKind;
 
   /**
    * Options defined and used by the plugins
@@ -41,6 +39,11 @@ export interface Attribute<T extends AttributeType = AttributeType> {
   pluginOptions?: object;
 }
 
+/**
+ * Creates a basic Attribute of type T
+ */
+export type OfType<T extends Kind> = Attribute<T>;
+
 // Common attributes Options
 
 export interface RequiredOption {

package/lib/types/core/attributes/biginteger.d.ts

@@ -1,22 +1,15 @@
-import {
-  Attribute,
-  ConfigurableOption,
-  DefaultOption,
-  MinMaxOption,
-  PrivateOption,
-  RequiredOption,
-} from './base';
+import type { Attribute } from '@strapi/strapi';
 
-export type BigIntegerAttribute = Attribute<'biginteger'> &
+export type BigInteger = Attribute.OfType<'biginteger'> &
   // Options
-  ConfigurableOption &
-  DefaultOption<BigIntegerValue> &
-  MinMaxOption<string> &
-  PrivateOption &
-  RequiredOption;
+  Attribute.ConfigurableOption &
+  Attribute.DefaultOption<BigIntegerValue> &
+  Attribute.MinMaxOption<string> &
+  Attribute.PrivateOption &
+  Attribute.RequiredOption;
 
 export type BigIntegerValue = string;
 
-export type GetBigIntegerAttributeValue<T extends Attribute> = T extends BigIntegerAttribute
+export type GetBigIntegerValue<T extends Attribute.Attribute> = T extends BigInteger
   ? BigIntegerValue
   : never;

package/lib/types/core/attributes/boolean.d.ts

@@ -1,20 +1,14 @@
-import {
-  Attribute,
-  ConfigurableOption,
-  DefaultOption,
-  PrivateOption,
-  RequiredOption,
-} from './base';
+import type { Attribute } from '@strapi/strapi';
 
-export type BooleanAttribute = Attribute<'boolean'> &
+export type Boolean = Attribute.OfType<'boolean'> &
   // Options
-  ConfigurableOption &
-  DefaultOption<BooleanValue> &
-  PrivateOption &
-  RequiredOption;
+  Attribute.ConfigurableOption &
+  Attribute.DefaultOption<BooleanValue> &
+  Attribute.PrivateOption &
+  Attribute.RequiredOption;
 
 export type BooleanValue = boolean;
 
-export type GetBooleanAttributeValue<T extends Attribute> = T extends BooleanAttribute
+export type GetBooleanValue<T extends Attribute.Attribute> = T extends Boolean
   ? BooleanValue
   : never;

package/lib/types/core/attributes/common.d.ts

@@ -2,47 +2,73 @@
  * Strapi custom scalar types
  */
 
-import { MinMaxLengthOption, MinMaxOption } from './base';
-import { StringAttribute } from './string';
-
-export type JSON<T extends object = object> = T;
-
-export type Media = any;
+import { Attribute, Common } from '@strapi/strapi';
 
 /**
  * Setters for the attributes options
  */
 
 // required
-export type RequiredAttribute = { required: true };
-export type NonRequiredAttribute = { required: false };
+export type Required = { required: true };
+export type NonRequired = { required: false };
 
 // private
-export type PrivateAttribute = { private: true };
-export type NonPrivateAttribute = { private: false };
+export type Private = { private: true };
+export type NonPrivate = { private: false };
 
 // unique
-export type UniqueAttribute = { unique: true };
-export type NonUniqueAttribute = { unique: false };
+export type Unique = { unique: true };
+export type NonUnique = { unique: false };
 
 // configurable
-export type ConfigurableAttribute = { configurable: true };
-export type NonConfigurableAttribute = { configurable: false };
+export type Configurable = { configurable: true };
+export type NonConfigurable = { configurable: false };
 
 // custom field
-export type CustomField<T extends string, P extends object = undefined> = {
-  customField: T;
-  options?: P;
+export type CustomField<TKind extends string, TOptions extends object | undefined = undefined> = {
+  customField: TKind;
+  options?: TOptions;
 };
 
 // min/max
-export type SetMinMax<T extends MinMaxOption<U>, U = number> = T;
+export type SetMinMax<TConfig extends Attribute.MinMaxOption<TType>, TType = number> = TConfig;
 
 // minLength/maxLength
-export type SetMinMaxLength<T extends MinMaxLengthOption> = T;
+export type SetMinMaxLength<TConfig extends Attribute.MinMaxLengthOption> = TConfig;
 
 // pluginOptions
-export type SetPluginOptions<T extends object = object> = { pluginOptions?: T };
+export type SetPluginOptions<TConfig extends object = object> = { pluginOptions?: TConfig };
 
 // default
 export type DefaultTo<T> = { default: T };
+
+// Any Attribute
+export type Any =
+  | Attribute.BigInteger
+  | Attribute.Boolean
+  | Attribute.Component<Common.UID.Component, boolean>
+  | Attribute.DateTime
+  | Attribute.Date
+  | Attribute.Decimal
+  | Attribute.DynamicZone
+  | Attribute.Email
+  | Attribute.Enumeration<string[]>
+  | Attribute.Float
+  | Attribute.Integer
+  | Attribute.JSON
+  | Attribute.Media<Attribute.MediaKind | undefined, boolean>
+  | Attribute.Password
+  | (
+      | Attribute.Relation<
+          Common.UID.Schema,
+          Attribute.RelationKind.BiDirectional,
+          Common.UID.Schema
+        >
+      | Attribute.Relation<Common.UID.Schema, Attribute.RelationKind.UniDirectional>
+    )
+  | Attribute.RichText
+  | Attribute.String
+  | Attribute.Text
+  | Attribute.Time
+  | Attribute.Timestamp
+  | Attribute.UID<Common.UID.Schema | undefined>;

package/lib/types/core/attributes/component.d.ts

@@ -1,38 +1,33 @@
-import { Attribute, ConfigurableOption, MinMaxOption, PrivateOption, RequiredOption } from './base';
-import { GetAttributesValues } from './utils';
+import type { Common, Attribute, Utils } from '@strapi/strapi';
 
-export interface ComponentAttributeProperties<
-  // Targeted component
-  T extends Strapi.ComponentUIDs,
-  // Repeatable
-  R extends boolean = false
+export interface ComponentProperties<
+  TComponentUID extends Common.UID.Component,
+  TRepeatable extends Utils.Expression.BooleanValue = Utils.Expression.False
 > {
-  component: T;
-  repeatable?: R;
+  component: TComponentUID;
+  repeatable?: TRepeatable;
 }
 
-export type ComponentAttribute<
-  // Targeted component
-  T extends Strapi.ComponentUIDs,
-  // Repeatable
-  R extends boolean = false
-> = Attribute<'component'> &
+export type Component<
+  TComponentUID extends Common.UID.Component = Common.UID.Component,
+  TRepeatable extends Utils.Expression.BooleanValue = Utils.Expression.False
+> = Attribute.OfType<'component'> &
   // Component Properties
-  ComponentAttributeProperties<T, R> &
+  ComponentProperties<TComponentUID, TRepeatable> &
   // Options
-  ConfigurableOption &
-  MinMaxOption &
-  PrivateOption &
-  RequiredOption;
+  Attribute.ConfigurableOption &
+  Attribute.MinMaxOption &
+  Attribute.PrivateOption &
+  Attribute.RequiredOption;
 
 export type ComponentValue<
-  T extends Strapi.ComponentUIDs,
-  R extends boolean
-> = GetAttributesValues<T> extends infer V ? (R extends true ? V[] : V) : never;
-
-export type GetComponentAttributeValue<T extends Attribute> = T extends ComponentAttribute<
-  infer U,
-  infer R
->
-  ? ComponentValue<U, R>
+  TComponentUID extends Common.UID.Component,
+  TRepeatable extends Utils.Expression.BooleanValue
+> = Attribute.GetValues<TComponentUID> extends infer TValues
+  ? Utils.Expression.If<TRepeatable, TValues[], TValues>
   : never;
+
+export type GetComponentValue<TAttribute extends Attribute.Attribute> =
+  TAttribute extends Component<infer TComponentUID, infer TRepeatable>
+    ? ComponentValue<TComponentUID, TRepeatable>
+    : never;

package/lib/types/core/attributes/date-time.d.ts

@@ -1,22 +1,15 @@
-import {
-  Attribute,
-  ConfigurableOption,
-  DefaultOption,
-  PrivateOption,
-  RequiredOption,
-  UniqueOption,
-} from './base';
+import type { Attribute } from '@strapi/strapi';
 
-export type DateTimeAttribute = Attribute<'datetime'> &
+export type DateTime = Attribute.OfType<'datetime'> &
   // Options
-  ConfigurableOption &
-  DefaultOption<DateTimeValue> &
-  PrivateOption &
-  RequiredOption &
-  UniqueOption;
+  Attribute.ConfigurableOption &
+  Attribute.DefaultOption<DateTimeValue> &
+  Attribute.PrivateOption &
+  Attribute.RequiredOption &
+  Attribute.UniqueOption;
 
 export type DateTimeValue = string;
 
-export type GetDateTimeAttributeValue<T extends Attribute> = T extends DateTimeAttribute
+export type GetDateTimeValue<T extends Attribute.Attribute> = T extends DateTime
   ? DateTimeValue
   : never;

package/lib/types/core/attributes/date.d.ts

@@ -1,22 +1,13 @@
-import {
-  Attribute,
-  ConfigurableOption,
-  DefaultOption,
-  PrivateOption,
-  RequiredOption,
-  UniqueOption,
-} from './base';
+import type { Attribute } from '@strapi/strapi';
 
-export type DateAttribute = Attribute<'date'> &
+export type Date = Attribute.OfType<'date'> &
   // Options
-  ConfigurableOption &
-  DefaultOption<DateValue> &
-  PrivateOption &
-  RequiredOption &
-  UniqueOption;
+  Attribute.ConfigurableOption &
+  Attribute.DefaultOption<DateValue> &
+  Attribute.PrivateOption &
+  Attribute.RequiredOption &
+  Attribute.UniqueOption;
 
 export type DateValue = Date;
 
-export type GetDateAttributeValue<T extends Attribute> = T extends DateAttribute
-  ? DateValue
-  : never;
+export type GetDateValue<T extends Attribute.Attribute> = T extends Date ? DateValue : never;

package/lib/types/core/attributes/decimal.d.ts

@@ -1,22 +1,15 @@
-import {
-  Attribute,
-  ConfigurableOption,
-  DefaultOption,
-  MinMaxOption,
-  PrivateOption,
-  RequiredOption,
-} from './base';
+import type { Attribute } from '@strapi/strapi';
 
-export type DecimalAttribute = Attribute<'decimal'> &
+export type Decimal = Attribute.OfType<'decimal'> &
   // Options
-  ConfigurableOption &
-  DefaultOption<DecimalValue> &
-  MinMaxOption &
-  PrivateOption &
-  RequiredOption;
+  Attribute.ConfigurableOption &
+  Attribute.DefaultOption<DecimalValue> &
+  Attribute.MinMaxOption &
+  Attribute.PrivateOption &
+  Attribute.RequiredOption;
 
 export type DecimalValue = number;
 
-export type GetDecimalAttributeValue<T extends Attribute> = T extends DecimalAttribute
+export type GetDecimalValue<T extends Attribute.Attribute> = T extends Decimal
   ? DecimalValue
   : never;

package/lib/types/core/attributes/dynamic-zone.d.ts

@@ -1,29 +1,26 @@
-import { SchemaUID, GetArrayValues } from '../../utils';
-import { Attribute, ConfigurableOption, MinMaxOption, RequiredOption } from './base';
-import { GetAttributesValues } from './utils';
+import type { Utils, Attribute, Common } from '@strapi/strapi';
 
-export interface DynamicZoneAttributeProperties<T extends Strapi.ComponentUIDs[] = []> {
-  components: T;
+export interface DynamicZoneProperties<TComponentsUIDs extends Common.UID.Component[]> {
+  components: TComponentsUIDs;
 }
 
-export type DynamicZoneAttribute<T extends Strapi.ComponentUIDs[] = []> = Attribute<'dynamiczone'> &
-  // Properties
-  DynamicZoneAttributeProperties<T> &
-  // Options
-  ConfigurableOption &
-  MinMaxOption &
-  RequiredOption;
+export type DynamicZone<TComponentsUIDs extends Common.UID.Component[] = Common.UID.Component[]> =
+  Attribute.OfType<'dynamiczone'> &
+    // Properties
+    DynamicZoneProperties<TComponentsUIDs> &
+    // Options
+    Attribute.ConfigurableOption &
+    Attribute.MinMaxOption &
+    Attribute.RequiredOption;
 
-type DynamicZoneValue<T extends Strapi.ComponentUIDs[]> = Array<
-  GetArrayValues<T> extends infer P
-    ? P extends SchemaUID
-      ? GetAttributesValues<P> & { __component: P }
+type DynamicZoneValue<TComponentsUIDs extends Common.UID.Component[]> = Array<
+  // Extract tuple values to a component uid union type
+  Utils.Array.Values<TComponentsUIDs> extends infer TComponentUID
+    ? TComponentUID extends Common.UID.Component
+      ? Attribute.GetValues<TComponentUID> & { __component: TComponentUID }
       : never
     : never
 >;
 
-export type GetDynamicZoneAttributeValue<T extends Attribute> = T extends DynamicZoneAttribute<
-  infer U
->
-  ? DynamicZoneValue<U>
-  : never;
+export type GetDynamicZoneValue<TAttribute extends Attribute.Attribute> =
+  TAttribute extends DynamicZone<infer TComponentsUIDs> ? DynamicZoneValue<TComponentsUIDs> : never;

package/lib/types/core/attributes/email.d.ts

@@ -1,24 +1,14 @@
-import {
-  Attribute,
-  ConfigurableOption,
-  DefaultOption,
-  MinMaxLengthOption,
-  PrivateOption,
-  RequiredOption,
-  UniqueOption,
-} from './base';
+import type { Attribute } from '@strapi/strapi';
 
-export type EmailAttribute = Attribute<'email'> &
+export type Email = Attribute.OfType<'email'> &
   // Options
-  ConfigurableOption &
-  DefaultOption<EmailValue> &
-  MinMaxLengthOption &
-  PrivateOption &
-  RequiredOption &
-  UniqueOption;
+  Attribute.ConfigurableOption &
+  Attribute.DefaultOption<EmailValue> &
+  Attribute.MinMaxLengthOption &
+  Attribute.PrivateOption &
+  Attribute.RequiredOption &
+  Attribute.UniqueOption;
 
 export type EmailValue = string;
 
-export type GetEmailAttributeValue<T extends Attribute> = T extends EmailAttribute
-  ? EmailValue
-  : never;
+export type GetEmailValue<T extends Attribute.Attribute> = T extends Email ? EmailValue : never;

package/lib/types/core/attributes/enumeration.d.ts

@@ -1,28 +1,18 @@
-import { GetArrayValues } from '../../utils';
-import {
-  Attribute,
-  ConfigurableOption,
-  DefaultOption,
-  PrivateOption,
-  RequiredOption,
-} from './base';
+import type { Attribute, Utils } from '@strapi/strapi';
 
-export interface EnumerationAttributeProperties<T extends string[] = []> {
-  enum: T;
+export interface EnumerationProperties<TValues extends string[] = []> {
+  enum: TValues;
 }
 
-export type EnumerationAttribute<T extends string[] = []> = Attribute<'enumeration'> &
-  EnumerationAttributeProperties<T> &
+export type Enumeration<TValues extends string[] = []> = Attribute.OfType<'enumeration'> &
+  EnumerationProperties<TValues> &
   // Options
-  ConfigurableOption &
-  DefaultOption<T> &
-  PrivateOption &
-  RequiredOption;
+  Attribute.ConfigurableOption &
+  Attribute.DefaultOption<TValues> &
+  Attribute.PrivateOption &
+  Attribute.RequiredOption;
 
-export type EnumerationValue<T extends string[]> = GetArrayValues<T>;
+export type EnumerationValue<TValues extends string[]> = Utils.Array.Values<TValues>;
 
-export type GetEnumerationAttributeValue<T extends Attribute> = T extends EnumerationAttribute<
-  infer U
->
-  ? EnumerationValue<U>
-  : never;
+export type GetEnumerationValue<TAttribute extends Attribute.Attribute> =
+  TAttribute extends Enumeration<infer TValues> ? EnumerationValue<TValues> : never;