@strapi/strapi 4.14.0-beta.0 → 4.15.0-alpha.0

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

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

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

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

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

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

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

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

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

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

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

@@ -1,43 +0,0 @@
-import type { Attribute, Common, Utils } from '@strapi/strapi';
-
-export interface UIDOptions {
-  separator?: string;
-  lowercase?: boolean;
-  decamelize?: boolean;
-  customReplacements?: Array<[string, string]>;
-  preserveLeadingUnderscore?: boolean;
-}
-
-export interface UIDProperties<
-  TTargetAttribute extends string = string,
-  TOptions extends UIDOptions = UIDOptions
-> {
-  targetField: TTargetAttribute;
-  options: UIDOptions & TOptions;
-}
-
-export type UID<
-  // TODO: V5:
-  // The TOrigin was used to narrow down the list of possible target attribute for a
-  // UID, but was removed due to circular dependency issues and will be removed in V5
-  _TOrigin extends Common.UID.Schema = never,
-  TTargetAttribute extends string = string,
-  TOptions extends UIDOptions = UIDOptions
-> = Attribute.OfType<'uid'> &
-  // Properties
-  UIDProperties<TTargetAttribute, TOptions> &
-  // Options
-  Attribute.ConfigurableOption &
-  Attribute.DefaultOption<UIDValue> &
-  Attribute.MinMaxLengthOption &
-  Attribute.PrivateOption &
-  Attribute.RequiredOption;
-
-export type UIDValue = string;
-
-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,143 +0,0 @@
-import type { Attribute, Common, Utils } from '@strapi/strapi';
-
-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 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 Get<TSchemaUID extends Common.UID.Schema, TKey extends GetKeys<TSchemaUID>> = Utils.Get<
-  GetAll<TSchemaUID>,
-  TKey
->;
-
-export type GetAll<TSchemaUID extends Common.UID.Schema> = Utils.Get<
-  Common.Schemas[TSchemaUID],
-  'attributes'
->;
-
-export type GetTarget<TSchemaUID extends Common.UID.Schema, TKey extends GetKeys<TSchemaUID>> = Get<
-  TSchemaUID,
-  TKey
-> extends infer TAttribute extends Attribute.Attribute
-  ?
-      | Attribute.GetRelationTarget<TAttribute>
-      | Attribute.GetComponentTarget<TAttribute>
-      | Attribute.GetMediaTarget<TAttribute>
-  : never;
-
-export type GetMorphTargets<
-  TSchemaUID extends Common.UID.Schema,
-  TKey extends GetKeys<TSchemaUID>
-> = Get<TSchemaUID, TKey> extends infer TAttribute extends Attribute.Attribute
-  ? Attribute.GetDynamicZoneTargets<TAttribute>
-  : never;
-
-export type GetKeys<TSchemaUID extends Common.UID.Schema> = keyof GetAll<TSchemaUID>;
-
-export type GetNonPopulatableKeys<TSchemaUID extends Common.UID.Schema> = GetKeysByType<
-  TSchemaUID,
-  Attribute.NonPopulatableKind
->;
-
-export type GetPopulatableKeys<TSchemaUID extends Common.UID.Schema> = GetKeysByType<
-  TSchemaUID,
-  Attribute.PopulatableKind
->;
-
-export type GetKeysWithTarget<TSchemaUID extends Common.UID.Schema> = keyof {
-  [key in GetKeys<TSchemaUID> as GetTarget<TSchemaUID, key> extends never ? never : key]: never;
-} extends infer TKey extends GetKeys<TSchemaUID>
-  ? TKey
-  : never;
-
-export type GetValue<TAttribute extends Attribute.Attribute, TGuard = unknown> = Utils.Guard.Never<
-  | 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>,
-  TGuard
->;
-
-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 GetValues<
-  TSchemaUID extends Common.UID.Schema,
-  TKey extends GetKeys<TSchemaUID> = GetKeys<TSchemaUID>
-> = { id: number | `${number}` } & {
-  // Handle required attributes
-  [key in GetRequiredKeys<TSchemaUID> as key extends TKey ? key : never]-?: GetValueByKey<
-    TSchemaUID,
-    key
-  >;
-} & {
-  // Handle optional attributes
-  [key in GetOptionalKeys<TSchemaUID> as key extends TKey ? key : never]?: GetValueByKey<
-    TSchemaUID,
-    key
-  >;
-};
-
-export type GetRequiredKeys<TSchemaUID extends Common.UID.Schema> = Utils.Object.KeysBy<
-  GetAll<TSchemaUID>,
-  Attribute.Required
->;
-
-export type GetOptionalKeys<TSchemaUID extends Common.UID.Schema> = Utils.Object.KeysExcept<
-  GetAll<TSchemaUID>,
-  Attribute.Required
->;
-
-export type HasTarget<
-  TSchemaUID extends Common.UID.Schema,
-  TField extends Attribute.GetKeys<TSchemaUID>
-> = GetTarget<TSchemaUID, TField> extends infer TTarget
-  ? Utils.Expression.And<
-      Utils.Expression.IsNotNever<TTarget>,
-      Utils.Expression.Extends<TTarget, Common.UID.Schema>
-    >
-  : Utils.Expression.False;
-
-export type HasMorphTargets<
-  TSchemaUID extends Common.UID.Schema,
-  TField extends Attribute.GetKeys<TSchemaUID>
-> = GetMorphTargets<TSchemaUID, TField> extends infer TMaybeTargets
-  ? Utils.Expression.And<
-      Utils.Expression.IsNotNever<TMaybeTargets>,
-      Utils.Expression.Extends<TMaybeTargets, Common.UID.Schema>
-    >
-  : Utils.Expression.False;

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

@@ -1,6 +0,0 @@
-import { Command } from 'commander';
-
-export type AddCommandOptions = {
-  command: Command;
-  argv: Record<number, string>;
-};

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

@@ -1,8 +0,0 @@
-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

@@ -1,16 +0,0 @@
-import type { Attribute, Common, Utils } from '@strapi/strapi';
-
-export * from './controller';
-export * from './service';
-export * from './schema';
-export * as UID from './uid';
-
-/**
- * Determines if the shared registries for components and content types have been extended or if they're still represented as loose mapped types
- *
- * Here we use the fact that once the registries are extended, Attribute.GetKeys<Common.UID.Schema> will resolve to either never or a more
- * deterministic value rather than string | number which represent the keys of the initial mapped type (Component & ContentType's registries)
- */
-export type AreSchemaRegistriesExtended = Utils.Expression.Not<
-  Utils.Expression.Extends<string | number, Attribute.GetKeys<Common.UID.Schema>>
->;

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

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

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

@@ -1,5 +0,0 @@
-export type Service = {
-  // TODO [V5] Consider changing the any value to unknown.
-  // See: https://github.com/strapi/strapi/issues/16993 and https://github.com/strapi/strapi/pull/17020 for further information
-  [key: keyof any]: any;
-};

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

@@ -1,58 +0,0 @@
-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<TSchemaUID extends Schema> = TSchemaUID extends CollectionType
-  ? Utils.Expression.Extends<Shared.ContentTypes[TSchemaUID], SchemaNamespace.CollectionType>
-  : Utils.Expression.False;
-
-export type IsSingleType<TSchemaUID extends Schema> = TSchemaUID extends SingleType
-  ? Utils.Expression.Extends<Shared.ContentTypes[TSchemaUID], SchemaNamespace.SingleType>
-  : Utils.Expression.False;
-
-export type IsComponent<TSchemaUID extends Schema> = TSchemaUID extends Component
-  ? Utils.Expression.Extends<Shared.Components[TSchemaUID], SchemaNamespace.Component>
-  : Utils.Expression.False;
-
-export type IsContentType<TSchemaUID extends Schema> = TSchemaUID extends ContentType
-  ? Utils.Expression.Or<IsCollectionType<TSchemaUID>, IsSingleType<TSchemaUID>>
-  : Utils.Expression.False;

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

@@ -1,9 +0,0 @@
-export * as Attribute from './attributes';
-export * as Schema from './schemas';
-export * as Plugin from './plugins';
-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

@@ -1,99 +0,0 @@
-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/plugins/index.d.ts

@@ -1,16 +0,0 @@
-import type { Common, Shared, Utils } from '@strapi/strapi';
-
-export type IsEnabled<
-  TName extends keyof any,
-  TSchemaUID extends Common.UID.Schema
-> = TName extends keyof Shared.PluginActivation
-  ? Shared.PluginActivation[TName] extends infer TRule
-    ? Utils.Expression.Or<
-        Utils.Expression.Not<Common.AreSchemaRegistriesExtended>,
-        Utils.Expression.Extends<
-          Common.Schemas[TSchemaUID]['pluginOptions'],
-          { [key in TName]: TRule }
-        >
-      >
-    : false
-  : false;

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

@@ -1,68 +0,0 @@
-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];
-};