@strapi/strapi 4.11.0 → 4.11.1-beta.0

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

@@ -1,22 +1,13 @@
-import {
-  Attribute,
-  ConfigurableOption,
-  DefaultOption,
-  MinMaxOption,
-  PrivateOption,
-  RequiredOption,
-} from './base';
+import type { Attribute } from '@strapi/strapi';
 
-export type FloatAttribute = Attribute<'float'> &
+export type Float = Attribute.OfType<'float'> &
   // Options
-  ConfigurableOption &
-  DefaultOption<FloatValue> &
-  MinMaxOption &
-  PrivateOption &
-  RequiredOption;
+  Attribute.ConfigurableOption &
+  Attribute.DefaultOption<FloatValue> &
+  Attribute.MinMaxOption &
+  Attribute.PrivateOption &
+  Attribute.RequiredOption;
 
 export type FloatValue = number;
 
-export type GetFloatAttributeValue<T extends Attribute> = T extends FloatAttribute
-  ? FloatValue
-  : never;
+export type GetFloatValue<T extends Attribute.Attribute> = T extends Float ? FloatValue : never;

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

@@ -1,22 +1,15 @@
-import {
-  Attribute,
-  ConfigurableOption,
-  DefaultOption,
-  MinMaxOption,
-  PrivateOption,
-  RequiredOption,
-} from './base';
+import type { Attribute } from '@strapi/strapi';
 
-export type IntegerAttribute = Attribute<'integer'> &
+export type Integer = Attribute.OfType<'integer'> &
   // Options
-  ConfigurableOption &
-  DefaultOption<IntegerValue> &
-  MinMaxOption &
-  PrivateOption &
-  RequiredOption;
+  Attribute.ConfigurableOption &
+  Attribute.DefaultOption<IntegerValue> &
+  Attribute.MinMaxOption &
+  Attribute.PrivateOption &
+  Attribute.RequiredOption;
 
 export type IntegerValue = number;
 
-export type GetIntegerAttributeValue<T extends Attribute> = T extends IntegerAttribute
+export type GetIntegerValue<T extends Attribute.Attribute> = T extends Integer
   ? IntegerValue
   : never;

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

@@ -1,14 +1,11 @@
-import { Attribute, ConfigurableOption, PrivateOption, RequiredOption } from './base';
-import { JSON } from './common';
+import type { Attribute } from '@strapi/strapi';
 
-export type JSONAttribute = Attribute<'json'> &
-  //Options
-  ConfigurableOption &
-  RequiredOption &
-  PrivateOption;
+export type JSON = Attribute.OfType<'json'> &
+  // Options
+  Attribute.ConfigurableOption &
+  Attribute.RequiredOption &
+  Attribute.PrivateOption;
 
-export type JsonValue = JSON;
+export type JsonValue<T extends object = object> = T;
 
-export type GetJsonAttributeValue<T extends Attribute> = T extends JSONAttribute
-  ? JsonValue
-  : never;
+export type GetJsonValue<T extends Attribute.Attribute> = T extends JSON ? JsonValue : never;

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

@@ -1,36 +1,34 @@
-import { Attribute, ConfigurableOption, PrivateOption, RequiredOption } from './base';
-import { Media } from './common';
+import type { Attribute, Utils } from '@strapi/strapi';
 
-export type AllowedMediaTypes = 'images' | 'videos' | 'files' | 'audios';
+export type MediaKind = 'images' | 'videos' | 'files' | 'audios';
 
-export interface MediaAttributeProperties<
-  // Media Type
-  T extends AllowedMediaTypes = undefined,
-  // Multiple
-  U extends boolean = false
+export interface MediaProperties<
+  TKind extends MediaKind | undefined = undefined,
+  TMultiple extends Utils.Expression.BooleanValue = Utils.Expression.False
 > {
-  allowedTypes?: T;
-  multiple?: U;
+  allowedTypes?: TKind;
+  multiple?: TMultiple;
 }
 
-export type MediaAttribute<
-  // Media Type
-  T extends AllowedMediaTypes = undefined,
-  // Multiple
-  U extends boolean = false
-> = Attribute<'media'> &
+export type Media<
+  TKind extends MediaKind | undefined = undefined,
+  TMultiple extends Utils.Expression.BooleanValue = Utils.Expression.False
+> = Attribute.OfType<'media'> &
   // Properties
-  MediaAttributeProperties<T, U> &
+  MediaProperties<TKind, TMultiple> &
   // Options
-  ConfigurableOption &
-  RequiredOption &
-  PrivateOption;
+  Attribute.ConfigurableOption &
+  Attribute.RequiredOption &
+  Attribute.PrivateOption;
 
-export type MediaValue<T extends boolean = false> = T extends true ? Media[] : Media;
+// TODO: Introduce a real type for the media values
+export type MediaValue<TMultiple extends Utils.Expression.BooleanValue = Utils.Expression.False> =
+  Utils.Expression.If<TMultiple, any[], any>;
 
-export type GetMediaAttributeValue<T extends Attribute> = T extends MediaAttribute<
-  infer _U,
-  infer S
+export type GetMediaValue<TAttribute extends Attribute.Attribute> = TAttribute extends Media<
+  // Unused as long as the media value is any
+  infer _TKind,
+  infer TMultiple
 >
-  ? MediaValue<S>
+  ? MediaValue<TMultiple>
   : never;

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

@@ -1,22 +1,15 @@
-import {
-  Attribute,
-  ConfigurableOption,
-  DefaultOption,
-  MinMaxLengthOption,
-  PrivateOption,
-  RequiredOption,
-} from './base';
+import type { Attribute } from '@strapi/strapi';
 
-export type PasswordAttribute = Attribute<'password'> &
+export type Password = Attribute.OfType<'password'> &
   // Options
-  ConfigurableOption &
-  DefaultOption<PasswordValue> &
-  MinMaxLengthOption &
-  PrivateOption &
-  RequiredOption;
+  Attribute.ConfigurableOption &
+  Attribute.DefaultOption<PasswordValue> &
+  Attribute.MinMaxLengthOption &
+  Attribute.PrivateOption &
+  Attribute.RequiredOption;
 
 export type PasswordValue = string;
 
-export type GetPasswordAttributeValue<T extends Attribute> = T extends PasswordAttribute
+export type GetPasswordValue<T extends Attribute.Attribute> = T extends Password
   ? PasswordValue
   : never;

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

@@ -1,63 +1,111 @@
-import { SchemaUID } from '../../utils';
-import { Attribute, ConfigurableOption, PrivateOption } from './base';
-import { GetAttributesByType, GetAttributesValues } from './utils';
-
-export type BasicRelationsType = 'oneToOne' | 'oneToMany' | 'manyToOne' | 'manyToMany';
-export type PolymorphicRelationsType = 'morphToOne' | 'morphToMany' | 'morphOne' | 'morphMany';
-export type RelationsType = BasicRelationsType | PolymorphicRelationsType;
-
-export interface BasicRelationAttributeProperties<
-  S extends SchemaUID,
-  R extends RelationsType,
-  T extends SchemaUID
-> {
-  relation: R;
-  target: T;
-  inversedBy?: RelationsKeysFromTo<T, S>;
-  mappedBy?: RelationsKeysFromTo<T, S>;
-}
-
-export interface PolymorphicRelationAttributeProperties<R extends RelationsType> {
-  relation: R;
-}
+import type { Attribute, Common, Utils } from '@strapi/strapi';
 
-export type RelationAttribute<
-  S extends SchemaUID,
-  R extends RelationsType,
-  T extends R extends PolymorphicRelationsType ? never : SchemaUID = never
-> = Attribute<'relation'> &
+export type Relation<
+  // TODO: TOrigin was originally needed to infer precise attribute literal types by doing a reverse lookup
+  // on TTarget -> TOrigin relations. Due to errors because of Attribute.Any [relation] very generic
+  // representation, type mismatches were encountered and mappedBy/inversedBy are now regular strings.
+  // It is kept to allow for future iterations without breaking the current type API
+  TOrigin extends Common.UID.Schema = Common.UID.Schema,
+  TRelationKind extends RelationKind.Any = RelationKind.Any,
+  TTarget extends Common.UID.Schema = never
+> = Attribute.OfType<'relation'> &
   // Properties
-  (R extends BasicRelationsType
-    ? BasicRelationAttributeProperties<S, R, T>
-    : PolymorphicRelationAttributeProperties<R>) &
+  RelationProperties<TOrigin, TRelationKind, TTarget> &
   // Options
-  ConfigurableOption &
-  PrivateOption;
+  Attribute.ConfigurableOption &
+  Attribute.PrivateOption;
+
+export type RelationProperties<
+  _TOrigin extends Common.UID.Schema,
+  TRelationKind extends RelationKind.Any,
+  TTarget extends Common.UID.Schema
+> = Utils.Expression.MatchFirst<
+  [
+    Utils.Expression.Test<
+      Utils.Expression.Extends<TRelationKind, RelationKind.BiDirectional>,
+      {
+        relation: TRelationKind;
+        target: TTarget;
+        inversedBy?: string;
+        mappedBy?: string;
+      }
+    >,
+    Utils.Expression.Test<
+      Utils.Expression.Extends<TRelationKind, RelationKind.UniDirectional>,
+      { relation: TRelationKind }
+    >,
+    Utils.Expression.Test<
+      Utils.Expression.Extends<TRelationKind, RelationKind.MorphReference>,
+      {
+        relation: TRelationKind;
+        target: TTarget;
+        morphBy?: Utils.Guard.Never<
+          Attribute.GetKeysByType<TTarget, 'relation', { relation: RelationKind.MorphOwner }>,
+          string
+        >;
+      }
+    >
+  ]
+>;
 
 export type RelationsKeysFromTo<
-  TTarget extends SchemaUID,
-  TSource extends SchemaUID
-> = keyof PickRelationsFromTo<TTarget, TSource>;
+  TTarget extends Common.UID.Schema,
+  TOrigin extends Common.UID.Schema
+> = keyof PickRelationsFromTo<TTarget, TOrigin>;
 
 export type PickRelationsFromTo<
-  TTarget extends SchemaUID,
-  TSource extends SchemaUID
-> = GetAttributesByType<TTarget, 'relation', { target: TSource }>;
+  TTarget extends Common.UID.Schema,
+  TOrigin extends Common.UID.Schema
+> = Attribute.GetByType<TTarget, 'relation', { target: TOrigin }>;
 
 export type RelationPluralityModifier<
-  TRelation extends RelationsType,
-  TValue extends Record<string, unknown>
-> = TRelation extends `${string}Many` ? TValue[] : TValue;
+  TRelationKind extends RelationKind.Any,
+  TValue
+> = TRelationKind extends Utils.String.Suffix<string, 'Many'> ? TValue[] : TValue;
 
 export type RelationValue<
-  TRelation extends RelationsType,
-  TTarget extends SchemaUID
-> = RelationPluralityModifier<TRelation, GetAttributesValues<TTarget>>;
+  TRelationKind extends RelationKind.Any,
+  TTarget extends Common.UID.Schema
+> = RelationPluralityModifier<TRelationKind, Attribute.GetValues<TTarget>>;
 
-export type GetRelationAttributeValue<T extends Attribute> = T extends RelationAttribute<
-  infer _TSource,
-  infer TRelation,
+export type GetRelationValue<TAttribute extends Attribute.Attribute> = TAttribute extends Relation<
+  infer _TOrigin,
+  infer TRelationKind,
   infer TTarget
 >
-  ? RelationValue<TRelation, TTarget>
+  ? RelationValue<TRelationKind, TTarget>
   : never;
+
+export module RelationKind {
+  type GetOppositePlurality<TPlurality extends RelationKind.Left | RelationKind.Right> = {
+    one: 'many';
+    One: 'Many';
+    many: 'one';
+    Many: 'One';
+  }[TPlurality];
+
+  export type Plurality = 'one' | 'many';
+
+  export type Left = Lowercase<RelationKind.Plurality>;
+  export type Right = Capitalize<RelationKind.Plurality>;
+
+  export type MorphOwner = `morphTo${RelationKind.Right}`;
+  export type MorphReference = `morph${RelationKind.Right}`;
+  export type Morph = RelationKind.MorphOwner | RelationKind.MorphReference;
+
+  export type XWay = `${RelationKind.Left}Way`;
+
+  export type BiDirectional = `${RelationKind.Left}To${RelationKind.Right}`;
+  export type UniDirectional = RelationKind.Morph | RelationKind.XWay;
+
+  export type Any = RelationKind.BiDirectional | RelationKind.UniDirectional;
+
+  export type Reverse<TRelationKind extends RelationKind.Any> =
+    TRelationKind extends `${infer TLeft extends RelationKind.Left}To${infer TRight extends RelationKind.Right}`
+      ? Utils.Expression.If<
+          Utils.Expression.Extends<Uppercase<TLeft>, Uppercase<TRight>>,
+          TRelationKind,
+          `${GetOppositePlurality<TLeft>}To${GetOppositePlurality<TRight>}`
+        >
+      : TRelationKind;
+}

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

@@ -1,22 +1,15 @@
-import {
-  Attribute,
-  ConfigurableOption,
-  DefaultOption,
-  MinMaxLengthOption,
-  PrivateOption,
-  RequiredOption,
-} from './base';
+import type { Attribute } from '@strapi/strapi';
 
-export type RichTextAttribute = Attribute<'richtext'> &
+export type RichText = Attribute.OfType<'richtext'> &
   // Options
-  ConfigurableOption &
-  DefaultOption<RichTextValue> &
-  MinMaxLengthOption &
-  PrivateOption &
-  RequiredOption;
+  Attribute.ConfigurableOption &
+  Attribute.DefaultOption<RichTextValue> &
+  Attribute.MinMaxLengthOption &
+  Attribute.PrivateOption &
+  Attribute.RequiredOption;
 
 export type RichTextValue = string;
 
-export type GetRichTextAttributeValue<T extends Attribute> = T extends RichTextAttribute
+export type GetRichTextValue<T extends Attribute.Attribute> = T extends RichText
   ? RichTextValue
   : never;

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

@@ -1,30 +1,20 @@
-import {
-  Attribute,
-  ConfigurableOption,
-  DefaultOption,
-  MinMaxLengthOption,
-  PrivateOption,
-  RequiredOption,
-  UniqueOption,
-} from './base';
+import type { Attribute } from '@strapi/strapi';
 
-export interface StringAttributeProperties {
+export interface StringProperties {
   regex?: RegExp;
 }
 
-export type StringAttribute = Attribute<'string'> &
+export type String = Attribute.OfType<'string'> &
   // Properties
-  StringAttributeProperties &
+  StringProperties &
   // Options
-  ConfigurableOption &
-  DefaultOption<StringValue> &
-  MinMaxLengthOption &
-  PrivateOption &
-  UniqueOption &
-  RequiredOption;
+  Attribute.ConfigurableOption &
+  Attribute.DefaultOption<StringValue> &
+  Attribute.MinMaxLengthOption &
+  Attribute.PrivateOption &
+  Attribute.UniqueOption &
+  Attribute.RequiredOption;
 
 export type StringValue = string;
 
-export type GetStringAttributeValue<T extends Attribute> = T extends StringAttribute
-  ? StringValue
-  : never;
+export type GetStringValue<T extends Attribute.Attribute> = T extends String ? StringValue : never;

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

@@ -1,30 +1,20 @@
-import {
-  Attribute,
-  ConfigurableOption,
-  DefaultOption,
-  MinMaxLengthOption,
-  PrivateOption,
-  RequiredOption,
-  UniqueOption,
-} from './base';
+import type { Attribute } from '@strapi/strapi';
 
-export interface TextAttributeProperties {
+export interface TextProperties {
   regex?: RegExp;
 }
 
-export type TextAttribute = Attribute<'text'> &
+export type Text = Attribute.OfType<'text'> &
   // Properties
-  TextAttributeProperties &
+  TextProperties &
   // Options
-  ConfigurableOption &
-  DefaultOption<TextValue> &
-  MinMaxLengthOption &
-  PrivateOption &
-  UniqueOption &
-  RequiredOption;
+  Attribute.ConfigurableOption &
+  Attribute.DefaultOption<TextValue> &
+  Attribute.MinMaxLengthOption &
+  Attribute.PrivateOption &
+  Attribute.UniqueOption &
+  Attribute.RequiredOption;
 
 export type TextValue = string;
 
-export type GetTextAttributeValue<T extends Attribute> = T extends TextAttribute
-  ? TextValue
-  : never;
+export type GetTextValue<T extends Attribute.Attribute> = T extends Text ? TextValue : never;

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

@@ -1,22 +1,13 @@
-import {
-  Attribute,
-  ConfigurableOption,
-  DefaultOption,
-  PrivateOption,
-  RequiredOption,
-  UniqueOption,
-} from './base';
+import type { Attribute } from '@strapi/strapi';
 
-export type TimeAttribute = Attribute<'time'> &
+export type Time = Attribute.OfType<'time'> &
   // Options
-  ConfigurableOption &
-  DefaultOption<TimeValue> &
-  PrivateOption &
-  RequiredOption &
-  UniqueOption;
+  Attribute.ConfigurableOption &
+  Attribute.DefaultOption<TimeValue> &
+  Attribute.PrivateOption &
+  Attribute.RequiredOption &
+  Attribute.UniqueOption;
 
 export type TimeValue = string;
 
-export type GetTimeAttributeValue<T extends Attribute> = T extends TimeAttribute
-  ? TimeValue
-  : never;
+export type GetTimeValue<T extends Attribute.Attribute> = T extends Time ? TimeValue : never;

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

@@ -1,22 +1,15 @@
-import {
-  Attribute,
-  ConfigurableOption,
-  DefaultOption,
-  PrivateOption,
-  RequiredOption,
-  UniqueOption,
-} from './base';
+import type { Attribute } from '@strapi/strapi';
 
-export type TimestampAttribute = Attribute<'timestamp'> &
+export type Timestamp = Attribute.OfType<'timestamp'> &
   // Options
-  ConfigurableOption &
-  DefaultOption<TimestampValue> &
-  PrivateOption &
-  RequiredOption &
-  UniqueOption;
+  Attribute.ConfigurableOption &
+  Attribute.DefaultOption<TimestampValue> &
+  Attribute.PrivateOption &
+  Attribute.RequiredOption &
+  Attribute.UniqueOption;
 
 export type TimestampValue = string;
 
-export type GetTimestampAttributeValue<T extends Attribute> = T extends TimestampAttribute
+export type GetTimestampValue<T extends Attribute.Attribute> = T extends Timestamp
   ? TimestampValue
   : never;

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

@@ -1,15 +1,6 @@
-import {
-  Attribute,
-  ConfigurableOption,
-  DefaultOption,
-  MinMaxLengthOption,
-  PrivateOption,
-  RequiredOption,
-} from './base';
-import { SchemaUID } from '../../utils';
-import { GetAttributesKeysByType } from './utils';
+import type { Attribute, Common, Utils } from '@strapi/strapi';
 
-export interface UIDAttributeOptions {
+export interface UIDOptions {
   separator?: string;
   lowercase?: boolean;
   decamelize?: boolean;
@@ -17,41 +8,46 @@ export interface UIDAttributeOptions {
   preserveLeadingUnderscore?: boolean;
 }
 
-export interface UIDAttributeProperties<
-  // Own Schema Reference
-  T extends SchemaUID | undefined = undefined,
-  // Target attribute
-  U extends T extends SchemaUID
-    ? GetAttributesKeysByType<T, 'string' | 'text'>
-    : undefined = undefined,
-  // UID options
-  S extends UIDAttributeOptions = UIDAttributeOptions
+export interface UIDProperties<
+  TOrigin extends Common.UID.Schema,
+  TTargetAttribute extends AllowedTargetAttributes<TOrigin>,
+  TOptions extends UIDOptions = UIDOptions
 > {
-  targetField?: U;
-  options?: UIDAttributeOptions & S;
+  targetField: TTargetAttribute;
+  options: UIDOptions & TOptions;
 }
 
-export type UIDAttribute<
-  // Own Schema Reference
-  T extends SchemaUID | undefined = undefined,
-  // Target attribute
-  U extends T extends SchemaUID
-    ? GetAttributesKeysByType<T, 'string' | 'text'>
-    : undefined = undefined,
-  // UID options
-  S extends UIDAttributeOptions = UIDAttributeOptions
-> = Attribute<'uid'> &
+export interface GenericUIDProperties<TOptions extends UIDOptions = UIDOptions> {
+  targetField?: string;
+  options: TOptions & UIDOptions;
+}
+
+export type UID<
+  TOrigin extends Common.UID.Schema | undefined = undefined,
+  TTargetAttribute extends AllowedTargetAttributes<TOrigin> = AllowedTargetAttributes<TOrigin>,
+  TOptions extends UIDOptions = UIDOptions
+> = Attribute.OfType<'uid'> &
   // Properties
-  UIDAttributeProperties<T, U, S> &
+  (TOrigin extends Common.UID.Schema
+    ? UIDProperties<TOrigin, TTargetAttribute, TOptions>
+    : GenericUIDProperties<TOptions>) &
   // Options
-  ConfigurableOption &
-  DefaultOption<UIDValue> &
-  MinMaxLengthOption &
-  PrivateOption &
-  RequiredOption;
+  Attribute.ConfigurableOption &
+  Attribute.DefaultOption<UIDValue> &
+  Attribute.MinMaxLengthOption &
+  Attribute.PrivateOption &
+  Attribute.RequiredOption;
+
+type AllowedTargetAttributes<TOrigin extends Common.UID.Schema | undefined> =
+  TOrigin extends Common.UID.Schema
+    ? Utils.Guard.Never<Attribute.GetKeysByType<TOrigin, 'string' | 'text'>, string>
+    : never;
 
 export type UIDValue = string;
 
-export type GetUIDAttributeValue<T extends Attribute> = T extends UIDAttribute<infer _U, infer _P>
+export type GetUIDValue<TAttribute extends Attribute.Attribute> = TAttribute extends UID<
+  infer _TOrigin,
+  infer _TTargetAttribute
+>
   ? UIDValue
   : never;