@strapi/strapi 4.11.0-exp.push-transfer-push-stuck → 4.11.1-beta.0

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;

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

@@ -1,98 +1,88 @@
-import { Get, KeysBy, NeverGuard, PickBy, SchemaUID } from '../../utils';
-import {
-  Attribute,
-  AttributeType,
-  GetBigIntegerAttributeValue,
-  GetBooleanAttributeValue,
-  GetDecimalAttributeValue,
-  GetDynamicZoneAttributeValue,
-  GetEnumerationAttributeValue,
-  GetFloatAttributeValue,
-  GetIntegerAttributeValue,
-  GetJsonAttributeValue,
-  GetMediaAttributeValue,
-  GetPasswordAttributeValue,
-  GetRelationAttributeValue,
-  GetRichTextAttributeValue,
-  GetStringAttributeValue,
-  GetTextAttributeValue,
-  GetUIDAttributeValue,
-  GetComponentAttributeValue,
-  GetEmailAttributeValue,
-} from '.';
-import { GetDateAttributeValue } from './date';
-import { GetDateTimeAttributeValue } from './date-time';
-import { GetTimeAttributeValue } from './time';
-import { GetTimestampAttributeValue } from './timestamp';
+import type { Attribute, Common, Utils } from '@strapi/strapi';
 
-export type PickTypes<T extends AttributeType> = T;
-
-export type GetAttributesKeysByType<
-  T extends SchemaUID,
-  U extends AttributeType,
-  P = never
-> = KeysBy<GetAttributes<T>, Attribute<U> & NeverGuard<P, unknown>>;
+export type GetKeysByType<
+  TSchemaUID extends Common.UID.Schema,
+  TKind extends Attribute.Kind,
+  TCondition = never
+> = Utils.Object.KeysBy<
+  GetAll<TSchemaUID>,
+  Attribute.OfType<TKind> & Utils.Guard.Never<TCondition, unknown>
+>;
 
-export type GetAttributesByType<T extends SchemaUID, U extends AttributeType, P = never> = PickBy<
-  GetAttributes<T>,
-  Attribute<U> & NeverGuard<P, unknown>
+export type GetByType<
+  TSchemaUID extends Common.UID.Schema,
+  TKind extends Attribute.Kind,
+  TCondition = never
+> = Utils.Object.PickBy<
+  GetAll<TSchemaUID>,
+  Attribute.OfType<TKind> & Utils.Guard.Never<TCondition, unknown>
 >;
 
-export type GetAttribute<T extends SchemaUID, U extends GetAttributesKey<T>> = Get<
-  GetAttributes<T>,
-  U
+export type Get<TSchemaUID extends Common.UID.Schema, TKey extends GetKeys<TSchemaUID>> = Utils.Get<
+  GetAll<TSchemaUID>,
+  TKey
 >;
 
-export type GetAttributes<T extends SchemaUID> = Get<Strapi.Schemas[T], 'attributes'>;
+export type GetAll<TSchemaUID extends Common.UID.Schema> = Utils.Get<
+  Common.Schemas[TSchemaUID],
+  'attributes'
+>;
 
-export type GetAttributesKey<T extends SchemaUID> = keyof GetAttributes<T>;
+export type GetKeys<TSchemaUID extends Common.UID.Schema> = keyof GetAll<TSchemaUID>;
 
-export type GetAttributeValue<T extends Attribute> =
-  | GetBigIntegerAttributeValue<T>
-  | GetBooleanAttributeValue<T>
-  | GetComponentAttributeValue<T>
-  | GetDecimalAttributeValue<T>
-  | GetDynamicZoneAttributeValue<T>
-  | GetEnumerationAttributeValue<T>
-  | GetEmailAttributeValue<T>
-  | GetFloatAttributeValue<T>
-  | GetIntegerAttributeValue<T>
-  | GetJsonAttributeValue<T>
-  | GetMediaAttributeValue<T>
-  | GetPasswordAttributeValue<T>
-  | GetRelationAttributeValue<T>
-  | GetRichTextAttributeValue<T>
-  | GetStringAttributeValue<T>
-  | GetTextAttributeValue<T>
-  | GetUIDAttributeValue<T>
-  | GetMediaAttributeValue<T>
-  | GetDateAttributeValue<T>
-  | GetDateTimeAttributeValue<T>
-  | GetTimeAttributeValue<T>
-  | GetTimestampAttributeValue<T>;
+export type GetValue<TAttribute extends Attribute.Attribute> =
+  | Attribute.GetBigIntegerValue<TAttribute>
+  | Attribute.GetBooleanValue<TAttribute>
+  | Attribute.GetComponentValue<TAttribute>
+  | Attribute.GetDecimalValue<TAttribute>
+  | Attribute.GetDynamicZoneValue<TAttribute>
+  | Attribute.GetEnumerationValue<TAttribute>
+  | Attribute.GetEmailValue<TAttribute>
+  | Attribute.GetFloatValue<TAttribute>
+  | Attribute.GetIntegerValue<TAttribute>
+  | Attribute.GetJsonValue<TAttribute>
+  | Attribute.GetMediaValue<TAttribute>
+  | Attribute.GetPasswordValue<TAttribute>
+  | Attribute.GetRelationValue<TAttribute>
+  | Attribute.GetRichTextValue<TAttribute>
+  | Attribute.GetStringValue<TAttribute>
+  | Attribute.GetTextValue<TAttribute>
+  | Attribute.GetUIDValue<TAttribute>
+  | Attribute.GetDateValue<TAttribute>
+  | Attribute.GetDateTimeValue<TAttribute>
+  | Attribute.GetTimeValue<TAttribute>
+  | Attribute.GetTimestampValue<TAttribute>;
 
-export type GetAttributeValueByKey<
-  T extends SchemaUID,
-  U extends GetAttributesKey<T>
-> = GetAttribute<T, U> extends infer P
-  ? P extends Attribute
-    ? GetAttributeValue<P>
-    : never
+export type GetValueByKey<
+  TSchemaUID extends Common.UID.Schema,
+  TKey extends GetKeys<TSchemaUID>
+> = Get<TSchemaUID, TKey> extends infer TAttribute extends Attribute.Attribute
+  ? GetValue<TAttribute>
   : never;
 
-export type GetAttributesValues<T extends SchemaUID> = {
+export type GetValues<
+  TSchemaUID extends Common.UID.Schema,
+  TKey extends GetKeys<TSchemaUID> = GetKeys<TSchemaUID>
+> = {
   // Handle required attributes
-  [key in GetAttributesRequiredKeys<T>]-?: GetAttributeValueByKey<T, key>;
+  [key in GetRequiredKeys<TSchemaUID> as key extends TKey ? key : never]-?: GetValueByKey<
+    TSchemaUID,
+    key
+  >;
 } & {
   // Handle optional attributes
-  [key in GetAttributesOptionalKeys<T>]?: GetAttributeValueByKey<T, key>;
+  [key in GetOptionalKeys<TSchemaUID> as key extends TKey ? key : never]?: GetValueByKey<
+    TSchemaUID,
+    key
+  >;
 };
 
-export type GetAttributesRequiredKeys<T extends SchemaUID> = KeysBy<
-  GetAttributes<T>,
+export type GetRequiredKeys<TSchemaUID extends Common.UID.Schema> = Utils.Object.KeysBy<
+  GetAll<TSchemaUID>,
   { required: true }
 >;
-export type GetAttributesOptionalKeys<T extends SchemaUID> = keyof Omit<
-  GetAttributes<T>,
-  GetAttributesRequiredKeys<T>
+
+export type GetOptionalKeys<TSchemaUID extends Common.UID.Schema> = keyof Omit<
+  GetAll<TSchemaUID>,
+  GetRequiredKeys<TSchemaUID>
 >;

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

@@ -0,0 +1,8 @@
+import type { ExtendableContext, Next } from 'koa';
+
+export type ControllerHandler = <TResponse = unknown>(
+  context: ExtendableContext,
+  next: Next
+) => Promise<TResponse | void> | TResponse | void;
+
+export type Controller = Record<string, ControllerHandler>;

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

@@ -0,0 +1,4 @@
+export * from './controller';
+export * from './service';
+export * from './schema';
+export * as UID from './uid';

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

@@ -0,0 +1,3 @@
+import type { Shared } from '@strapi/strapi';
+
+export type Schemas = Shared.ContentTypes & Shared.Components;

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

@@ -0,0 +1,3 @@
+export type Service = {
+  [key: keyof any]: unknown;
+};

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

@@ -0,0 +1,62 @@
+import type {
+  Shared,
+  Schema as SchemaNamespace,
+  Common,
+  Registry,
+  UID,
+  Utils,
+} from '@strapi/strapi';
+
+export type Service = Registry.Keys<Shared.Services, UID.Service>;
+
+export type Controller = Registry.Keys<Shared.Controllers, UID.Controller>;
+
+export type Policy = Registry.Keys<Shared.Policies, UID.Policy>;
+
+export type Middleware = Registry.Keys<Shared.Middlewares, UID.Middleware>;
+
+export type ContentType = Registry.Keys<Shared.ContentTypes, UID.ContentType>;
+
+export type CollectionType = Utils.Guard.Never<
+  // extract uids only for collection types
+  Extract<Utils.Object.KeysBy<Shared.ContentTypes, SchemaNamespace.CollectionType>, ContentType>,
+  // if no collection type is found (never), fallback to a generic content type uid
+  ContentType
+>;
+
+export type SingleType = Utils.Guard.Never<
+  // extract uids only for single types
+  Extract<Utils.Object.KeysBy<Shared.ContentTypes, SchemaNamespace.SingleType>, ContentType>,
+  // if no single type is found (never), fallback to a generic content type uid
+  ContentType
+>;
+
+export type Component = Registry.Keys<Shared.Components, UID.Component>;
+export type ComponentCategory = Component extends UID.Component<infer TCategory>
+  ? TCategory
+  : never;
+
+export type Schema = Registry.Keys<
+  Common.Schemas,
+  UID.ContentType | UID.Component<ComponentCategory>
+>;
+
+export type IsCollectionType<TContentTypeUID extends ContentType> = Utils.Expression.Extends<
+  Shared.ContentTypes[TContentTypeUID],
+  SchemaNamespace.CollectionType
+>;
+
+export type IsSingleType<TContentTypeUID extends ContentType> = Utils.Expression.Extends<
+  Shared.ContentTypes[TContentTypeUID],
+  SchemaNamespace.SingleType
+>;
+
+export type IsComponent<TComponentUID extends Component> = Utils.Expression.Extends<
+  Shared.Components[TComponentUID],
+  SchemaNamespace.Component
+>;
+
+export type IsContentType<TContentTypeUID extends ContentType> = Utils.Expression.Or<
+  IsCollectionType<TContentTypeUID>,
+  IsSingleType<TContentTypeUID>
+>;

package/lib/types/core/index.d.ts

@@ -1,3 +1,8 @@
-export * from './attributes';
-export * from './schemas';
+export * as Attribute from './attributes';
+export * as Schema from './schemas';
 export * from './strapi';
+
+export * as Common from './common';
+export * as Namespace from './namespace';
+export * as UID from './uid';
+export * as Registry from './registry';

package/lib/types/core/namespace.d.ts

@@ -0,0 +1,99 @@
+import type * as Utils from '../utils';
+
+/**
+ * Namespace for admin resources
+ */
+export type Admin = 'admin';
+
+/**
+ * Namespace for strapi internal resources
+ */
+export type Strapi = 'strapi';
+
+/**
+ * Namespace for scoped APIs resources
+ */
+export type API<T extends string = string> = `api${ColonsSeparator}${T}`;
+
+/**
+ * Namespace for scoped plugins resources
+ */
+export type Plugin<T extends string = string> = `plugin${ColonsSeparator}${T}`;
+
+/**
+ * Namespace for global resources
+ */
+export type Global = 'global';
+
+/**
+ * Represents any namespace
+ */
+export type Any = API | Plugin | Admin | Strapi | Global;
+
+/**
+ * Return a {@link Separator} based on the given {@link Any} ({@link DotSeparator} for {@link Scoped} and {@link ColonsSeparator} for regular ones)
+ *
+ * @example
+ * type S = GetSeparator<Admin>
+ * // ^ '::'
+ *
+ * type S = GetSeparator<API>
+ * // ^ '.'
+ *
+ * type S = GetSeparator<Admin | API>
+ * // ^ '.' | '::'
+ */
+export type GetSeparator<TNamespace extends Any = Any> = TNamespace extends Scoped
+  ? // 'api::foo' | 'plugin::bar' => '.'
+    DotSeparator
+  : // 'admin' | 'strapi' | 'global' => '::'
+    ColonsSeparator;
+
+/**
+ * Adds the corresponding separator (using {@link GetSeparator}) at the end of a namespace
+ *
+ * Warning: Using WithSeparator with a union type might produce undesired results as it'll distribute every matching suffix to every union member
+ *
+ * @example
+ * type T = WithSeparator<Admin>
+ * // ^ 'admin::'
+ *
+ * type T = WithSeparator<API>
+ * // ^ 'api::{string}.'
+ *
+ * type T = WithSeparator<Admin | API>
+ * // ^ 'admin::' | 'admin.' | 'api::{string}.' | 'api::{string}::'
+ *
+ * type T = WithSeparator<Admin> | WithSeparator<API>
+ * // ^ 'admin::' | 'api::{string}.'
+ */
+export type WithSeparator<TNamespace extends Any> = Utils.String.Suffix<
+  TNamespace,
+  GetSeparator<TNamespace>
+>;
+
+/**
+ * Represents namespaces composed of an origin and a scope, separated by colons
+ */
+export type Scoped<TOrigin extends string = string, TScope extends string = string> = Any &
+  `${TOrigin}${ColonsSeparator}${TScope}`;
+
+/**
+ * Extract the scope from the given scoped namespace
+ */
+export type ExtractScope<TNamespace> =
+  TNamespace extends `${string}${ColonsSeparator}${infer TScope}` ? TScope : never;
+
+/**
+ * Extract the origin from the given scoped namespace
+ */
+export type ExtractOrigin<TNamespace> =
+  TNamespace extends `${infer TOrigin}${ColonsSeparator}${string}` ? TOrigin : never;
+
+/**
+ * Separators used to join the different parts of a namespace (e.g. building a uid)
+ */
+export type Separator = ColonsSeparator | DotSeparator;
+
+type ColonsSeparator = '::';
+type DotSeparator = '.';