@strapi/strapi 4.11.0 → 4.11.1-beta.1

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 = '.';

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

@@ -0,0 +1,68 @@
+import type * as UID from './uid';
+
+/**
+ * Extract valid keys from a given registry.
+ *
+ * It looks for {@link UID.Any} by default but the search can be narrowed to any UID subset using the `TUidFormat` generic.
+ *
+ * @example
+ * interface Registry {
+ *   'foo': unknown;
+ *   'default.foo': 'unknown';
+ *   'global::foo': unknown;
+ *   'api::foo.bar': unknown;
+ * }
+ *
+ * type T = Keys<Registry>;
+ * // ^ 'default.foo' | 'global::foo' | 'api::foo.bar'
+ * type T = Keys<Registry, UID.Policy>;
+ * // ^ 'global::foo' | 'api::foo.bar'
+ * type T = Keys<Registry, UID.Service>
+ * // ^ 'api::foo.bar'
+ */
+export type Keys<TRegistry, TUidFormat extends UID.Any = UID.Any> = Extract<
+  keyof TRegistry,
+  TUidFormat
+>;
+
+/**
+ * Performs a `TQuery` filtering operation on the given `TRegistry` registry.
+ *
+ * `TQuery` needs to be a partial representation of a {@link UID.Parsed}
+ *
+ * Note: For additional filtering, the registry keys' type can be passed as the third parameter.
+ *
+ * @example
+ * interface Registry {
+ *   'admin::foo': unknown;
+ *   'admin::bar': unknown;
+ *   'api::foo.bar': unknown;
+ *   'api::foo.baz': unknown;
+ *   'api::bar.foo': unknown;
+ *   'plugin::foo.bar': unknown;
+ * }
+ *
+ * type T = keyof WhereKeys<Registry, { namespace: Namespace.API }>;
+ * // ^ "api::foo.bar" | "api::foo.baz" | "api::bar.foo"
+ *
+ * type T = keyof WhereKeys<Registry, { name: 'bar' }>;
+ * // ^ "admin::bar" | "api::foo.bar" | "plugin::foo.bar"
+ *
+ * type T = keyof WhereKeys<Registry, { separator: '.' }>;
+ * // ^ "api::foo.bar" | "api::foo.baz" | "api::bar.foo" | 'plugin::foo.bar"
+ *
+ * type T = keyof WhereKeys<Registry, { namespace: Namespace.Plugin | Namespace.Admin }>;
+ * // ^ "plugin::foo.bar" | "admin::foo" | "admin::bar"
+ *
+ * type T = keyof WhereKeys<Registry, { namespace: Namespace.API; name: Utils.Includes<'b'> }>;
+ * // ^ "api::foo.bar" | "api::foo.baz"
+ */
+export type WhereKeys<
+  TRegistry,
+  TQuery extends Partial<UID.Parsed>,
+  TUidFormat extends UID.Any = UID.Any
+> = {
+  [uid in Keys<TRegistry, TUidFormat> as UID.Parse<uid> extends TQuery
+    ? uid
+    : never]: TRegistry[uid];
+};

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

@@ -1,5 +1,4 @@
-import { Attribute, ComponentAttribute } from '../attributes';
-import { KeysBy, SchemaUID, StringRecord } from '../../utils';
+import type { Attribute, Utils, Common } from '@strapi/strapi';
 
 /**
  * Literal union type representing the possible natures of a content type
@@ -9,7 +8,7 @@ export type ContentTypeKind = 'singleType' | 'collectionType';
 /**
  * Literal union type representing the possible types of a model
  */
-export type SchemaModelType = 'contentType' | 'component';
+export type ModelType = 'contentType' | 'component';
 
 /**
  * Data structure that can either represent a content type or a component
@@ -18,17 +17,17 @@ export interface Schema {
   /**
    * The type of the model. Useful to discriminate content-types from component
    */
-  modelType: SchemaModelType;
+  modelType: ModelType;
 
   /**
    * Informations about schema naming and display
    */
-  info: SchemaInfo;
+  info: Info;
 
   /**
    * Map of all the attributes with their name and definition
    */
-  attributes: SchemaAttributes;
+  attributes: Attributes;
 
   /**
    * Options declared and read by the plugins
@@ -38,7 +37,7 @@ export interface Schema {
   /**
    * Options object dedicated to Strapi core features
    */
-  options?: SchemaOptions;
+  options?: Options;
 
   /**
    * Custom table name for the schema
@@ -49,7 +48,7 @@ export interface Schema {
 /**
  * Data structure containing naming and display information for a Schema
  */
-export interface SchemaInfo {
+export interface Info {
   /**
    * Default name to use in the admin panel
    */
@@ -79,12 +78,14 @@ export interface SchemaInfo {
 /**
  * Low level data structure referencing every schema attribute and its name
  */
-export interface SchemaAttributes extends StringRecord<Attribute> {}
+export interface Attributes {
+  [key: string]: Attribute.Any;
+}
 
 /**
  * Structure containing every core schema options and their associated value
  */
-export interface SchemaOptions {
+export interface Options {
   draftAndPublish?: boolean;
   populateCreatorFields?: boolean;
   comment?: string;
@@ -95,13 +96,13 @@ export interface PluginOptions {}
 /**
  * Schema for a content type
  */
-export interface ContentTypeSchema extends Schema {
+export interface ContentType extends Schema {
   modelType: 'contentType';
 
   /**
    * Unique identifier of the schema
    */
-  uid: SchemaUID;
+  uid: Common.UID.ContentType;
 
   /**
    * Determine the type of the content type (single-type or collection-type)
@@ -112,20 +113,20 @@ export interface ContentTypeSchema extends Schema {
 /**
  * Schema for a collection type
  */
-export interface CollectionTypeSchema extends ContentTypeSchema {
+export interface CollectionType extends ContentType {
   kind: 'collectionType';
 }
 
 /**
  * Schema for a single type
  */
-export interface SingleTypeSchema extends ContentTypeSchema {
+export interface SingleType extends ContentType {
   kind: 'singleType';
 }
 
 /**
  * Schema for a component
  */
-export interface ComponentSchema extends Schema {
+export interface Component extends Schema {
   modelType: 'component';
 }

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

@@ -1,9 +1,5 @@
-import type Koa from 'koa';
-import { Database } from '@strapi/database';
-
-import type { StringMap } from './utils';
-import type { GenericController } from '../../../core-api/controller';
-import type { GenericService } from '../../../core-api/service';
+import type { Database } from '@strapi/database';
+import type { Shared, Common } from '@strapi/strapi';
 
 // TODO move custom fields types to a separate file
 interface CustomFieldServerOptions {
@@ -69,24 +65,24 @@ export interface Strapi {
    *
    * It returns all the registered services
    */
-  readonly services: StringMap<GenericService>;
+  readonly services: Shared.Services;
 
   /**
    * Find a service using its unique identifier
    */
-  service<T extends GenericService = GenericService>(uid: string): T | undefined;
+  service<TService extends Common.Service = Common.Service>(uid: string): TService | undefined;
 
   /**
    * Getter for the Strapi controllers container
    *
    * It returns all the registered controllers
    */
-  readonly controllers: StringMap<GenericController>;
+  readonly controllers: Shared.Controllers;
 
   /**
    * Find a controller using its unique identifier
    */
-  controller(uid: string): GenericController | undefined;
+  controller<TContentTypeUID extends Common.UID.Controller>(uid: TContentTypeUID): Shared.Controllers[TContentTypeUID];
 
   /**
    * Getter for the Strapi content types container