@strapi/strapi 4.14.0-beta.0 → 4.14.1

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

@@ -1,167 +0,0 @@
-import type * as Namespace from './namespace';
-import type * as Utils from '../utils';
-
-type StringSuffix<T extends string> = Utils.String.Suffix<T, string>;
-
-/**
- * Template for services' unique identifier
- */
-export type Service = StringSuffix<
-  | Namespace.WithSeparator<Namespace.Admin>
-  | Namespace.WithSeparator<Namespace.API>
-  | Namespace.WithSeparator<Namespace.Plugin>
->;
-
-/**
- * Template for controllers' unique identifier
- */
-export type Controller = StringSuffix<
-  | Namespace.WithSeparator<Namespace.Admin>
-  | Namespace.WithSeparator<Namespace.API>
-  | Namespace.WithSeparator<Namespace.Plugin>
->;
-
-/**
- * Template for policies' unique identifier
- */
-export type Policy = StringSuffix<
-  | Namespace.WithSeparator<Namespace.Admin>
-  | Namespace.WithSeparator<Namespace.Strapi>
-  | Namespace.WithSeparator<Namespace.Global>
-  | Namespace.WithSeparator<Namespace.API>
-  | Namespace.WithSeparator<Namespace.Plugin>
->;
-
-/**
- * Template for middlewares' unique identifier
- */
-export type Middleware = StringSuffix<
-  | Namespace.WithSeparator<Namespace.Admin>
-  | Namespace.WithSeparator<Namespace.Strapi>
-  | Namespace.WithSeparator<Namespace.Global>
-  | Namespace.WithSeparator<Namespace.API>
-  | Namespace.WithSeparator<Namespace.Plugin>
->;
-
-/**
- * Template for content-types' unique identifier
- */
-export type ContentType = StringSuffix<
-  | Namespace.WithSeparator<Namespace.Admin>
-  | Namespace.WithSeparator<Namespace.Strapi>
-  | Namespace.WithSeparator<Namespace.API>
-  | Namespace.WithSeparator<Namespace.Plugin>
->;
-
-/**
- * Template for components' unique identifier
- *
- * @example
- * 'default.foo' extends Component => true (T = 'default', N = 'foo')
- *
- * @example
- * // /!\ Warning: Can cause overlap with other UID formats:
- * // 'api::foo.bar' both extends ContentType and Component
- * 'api::foo.bar' extends ContentType => true (N = 'api', S='::', T='foo')
- * 'api::foo.bar' extends Component   => true (T = 'api::foo', N = 'bar')
- */
-export type Component<
-  TCategory extends string = string,
-  TName extends string = string
-> = `${TCategory}.${TName}`;
-
-/**
- * Represents any UID
- */
-export type Any = Service | Controller | Policy | Middleware | ContentType | Component;
-
-/**
- * Type representation of every UID component.
- *
- * The separator type is automatically inferred from the given namespace
- */
-export interface Parsed<
-  TNamespace extends Namespace.Any = Namespace.Any,
-  TName extends string = string
-> {
-  raw: `${TNamespace}${Namespace.GetSeparator<TNamespace>}${TName}`;
-  namespace: TNamespace;
-  origin: TNamespace extends Namespace.Scoped ? Namespace.ExtractOrigin<TNamespace> : TNamespace;
-  scope: TNamespace extends Namespace.Scoped ? Namespace.ExtractScope<TNamespace> : never;
-  separator: Namespace.GetSeparator<TNamespace>;
-  name: TName;
-}
-
-/**
- * Parse a UID literal and returns a {@link Parsed} type.
- *
- * Warning: Using ParseUID with a union type might produce undesired results as it'll distribute every matching namespace parsing to every union member
- *
- * @example
- * type T = Parse<'admin::foo'>
- * // ^ { namespace: 'admin'; separator: '::'; name: 'foo'; }
- *
- * type T = Parse<'api::foo.bar'>
- * // ^ { namespace: 'api::foo'; separator: '.'; name: 'bar'; }
- *
- * type T = Parse<'admin::foo' | 'api::foo.bar'>
- * // ^ { namespace: 'admin' | 'api::foo' ; separator: '.' | '::'; name: 'foo' | 'bar' | 'foo.bar'; }
- */
-export type Parse<TUid extends Any> =
-  ExtractNamespace<TUid> extends infer TExtractedNamespace extends Namespace.Any
-    ? Namespace.GetSeparator<TExtractedNamespace> extends infer TSeparator extends Namespace.Separator
-      ? TUid extends `${infer TInferredNamespace extends TExtractedNamespace}${TSeparator}${infer TName extends string}`
-        ? Parsed<TInferredNamespace, TName>
-        : never
-      : never
-    : never;
-
-/**
- * Determines if the UID's namespace matches the given one.
- *
- * It returns TNamespace (the {@link Namespace.Any} literal) if there is a match, never otherwise.
- *
- * @example
- * type T = EnsureNamespaceMatches<'admin::foo', Namespace.Admin>
- * // ^ Namespace.Admin
- * @example
- * type T = EnsureNamespaceMatches<'foo.bar', Namespace.API>
- * // ^ never
- * @example
- * type T = EnsureNamespaceMatches<'api::foo.bar', Namespace.Plugin>
- * // ^ never
- */
-export type EnsureNamespaceMatches<
-  TUid extends Any,
-  TNamespace extends Namespace.Any
-> = TUid extends StringSuffix<Namespace.WithSeparator<TNamespace>> ? TNamespace : never;
-
-/**
- * Get parsed properties from a given raw UID
- */
-export type Get<TUid extends Any, TKey extends keyof Parsed> = Parse<TUid>[TKey];
-
-/**
- * Pick parsed properties from a given raw UID
- */
-export type Select<TUid extends Any, TKey extends keyof Parse<TUid>> = Pick<Parse<TUid>, TKey>;
-
-/**
- * Extract the namespace literal from a given UID.
- *
- * @example
- * type T = ExtractNamespace<'admin::foo'>
- * // ^ Namespace.Admin
- * @example
- * type T = ExtractNamespace<'api::foo.bar'>
- * // ^ Namespace.API
- * @example
- * type T = ExtractNamespace<'admin::foo' | 'api::foo.bar'>
- * // ^ Namespace.Admin | Namespace.API
- */
-export type ExtractNamespace<TUid extends Any> =
-  | EnsureNamespaceMatches<TUid, Namespace.Global>
-  | EnsureNamespaceMatches<TUid, Namespace.Admin>
-  | EnsureNamespaceMatches<TUid, Namespace.Strapi>
-  | EnsureNamespaceMatches<TUid, Namespace.API>
-  | EnsureNamespaceMatches<TUid, Namespace.Plugin>;

package/lib/types/core-api/controller.d.ts

@@ -1,54 +0,0 @@
-import type { Common, CoreApi, Utils } from '@strapi/strapi';
-import type { ExtendableContext } from 'koa';
-
-/**
- * Base Core-API controller type
- *
- * TODO: Make use of the T generic to type the other methods based on the given content type
- */
-export interface Base {
-  // TODO: Use actual entities instead of regular object
-  transformResponse<TData, TResponse>(data: TData, meta: object): TResponse;
-  sanitizeOutput<TData>(data: TData, ctx: ExtendableContext): Promise<TData>;
-  sanitizeInput<TData>(data: TData, ctx: ExtendableContext): Promise<TData>;
-  sanitizeQuery<TData>(ctx: ExtendableContext): Promise<TData>;
-  validateInput<TData>(data: TData, ctx: ExtendableContext): Promise<TData>;
-  validateQuery<TData>(ctx: ExtendableContext): Promise<TData>;
-}
-
-/**
- * Generic controller structure
- */
-export type Generic = {
-  [name: string]: Common.ControllerHandler;
-};
-
-/**
- * Core-API collection type controller
- */
-export interface CollectionType extends Base {
-  find?: Common.ControllerHandler;
-  findOne?: Common.ControllerHandler;
-  create?: Common.ControllerHandler;
-  update?: Common.ControllerHandler;
-  delete?: Common.ControllerHandler;
-}
-
-/**
- * Core-API single type controller
- */
-export interface SingleType extends Base {
-  find?: Common.ControllerHandler;
-  update?: Common.ControllerHandler;
-  delete?: Common.ControllerHandler;
-}
-
-export type ContentType<T extends Common.UID.ContentType> = Utils.Expression.MatchFirst<
-  [
-    Utils.Expression.Test<Common.UID.IsCollectionType<T>, CollectionType>,
-    Utils.Expression.Test<Common.UID.IsSingleType<T>, SingleType>
-  ],
-  Base
->;
-
-export type Extendable<T extends Common.UID.ContentType> = ContentType<T> & Generic;

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

@@ -1,3 +0,0 @@
-export * as Controller from './controller';
-export * as Service from './service';
-export * as Router from './router';

package/lib/types/core-api/router.d.ts

@@ -1,68 +0,0 @@
-import type { Common, Strapi, Utils } from '@strapi/strapi';
-
-import { ExtendableContext } from 'koa';
-import { Middleware as KoaMiddleware } from 'koa';
-
-export type MiddlewareFactory = (config: any, ctx: { strapi: Strapi }) => Middleware | null;
-
-export type Middleware = KoaMiddleware | MiddlewareFactory;
-
-export interface PolicyContext extends ExtendableContext {
-  type: string;
-}
-
-export type PolicyImplementation<TCfg = unknown> = (
-  ctx: PolicyContext,
-  cfg: TCfg,
-  { strapi }: { strapi: Strapi }
-) => boolean | undefined;
-
-type HandlerConfig = {
-  auth?: false | { scope: string[] };
-  policies?: Array<string | PolicyImplementation | { name: string; config: object }>;
-  middlewares?: Array<string | Middleware | { name: string; config: object }>;
-};
-
-export type Generic = {
-  [method: string | number | symbol]: HandlerConfig;
-};
-
-export interface SingleTypeRouterConfig extends Generic {
-  find?: HandlerConfig;
-  update?: HandlerConfig;
-  delete?: HandlerConfig;
-}
-
-export interface CollectionTypeRouterConfig extends Generic {
-  find?: HandlerConfig;
-  findOne?: HandlerConfig;
-  create?: HandlerConfig;
-  update?: HandlerConfig;
-  delete?: HandlerConfig;
-}
-
-export type RouterConfig<TContentTypeUID extends Common.UID.ContentType> = {
-  prefix?: string;
-  // TODO Refactor when we have a controller registry
-  only?: string[];
-  except?: string[];
-  config: Utils.Expression.MatchFirst<
-    [
-      Utils.Expression.Test<
-        Common.UID.IsCollectionType<TContentTypeUID>,
-        CollectionTypeRouterConfig
-      >,
-      Utils.Expression.Test<Common.UID.IsSingleType<TContentTypeUID>, SingleTypeRouterConfig>
-    ],
-    Generic
-  >;
-};
-
-export type Route = {
-  method: string;
-  path: string;
-};
-export type Router = {
-  prefix: string;
-  routes: Route[];
-};

package/lib/types/core-api/service.d.ts

@@ -1,50 +0,0 @@
-import type { Common, Utils } from '@strapi/strapi';
-
-// TODO Use actual entities instead of regular object
-type Entity = unknown;
-
-/**
- * Base Core-API service type
- */
-export interface Base {
-  getFetchParams?(params: object): object;
-}
-
-/**
- * Generic core api service structure
- */
-export type Generic = {
-  [key: keyof any]: unknown;
-};
-
-/**
- * Core-API collection type service
- */
-export interface CollectionType extends Base {
-  find?(params: object): Promise<Entity[]> | Entity[];
-  findOne?(entityId: string, params: object): Promise<Entity> | Entity;
-  create?(params: object): Promise<Entity> | Entity;
-  update?(entityId: string, params: object): Promise<Entity> | Entity;
-  delete?(entityId: string, params: object): Promise<Entity> | Entity;
-}
-
-/**
- * Core-API single type service
- */
-export interface SingleType extends Base {
-  find?(params: object): Promise<Entity> | Entity;
-  createOrUpdate?(params: object): Promise<Entity> | Entity;
-  delete?(params: object): Promise<Entity> | Entity;
-}
-
-export type ContentType<TContentTypeUID extends Common.UID.ContentType> =
-  Utils.Expression.MatchFirst<
-    [
-      Utils.Expression.Test<Common.UID.IsCollectionType<TContentTypeUID>, CollectionType>,
-      Utils.Expression.Test<Common.UID.IsSingleType<TContentTypeUID>, SingleType>
-    ],
-    Base
-  >;
-
-export type Extendable<TContentTypeUID extends Common.UID.ContentType> =
-  ContentType<TContentTypeUID> & Generic;

package/lib/types/index.d.ts

@@ -1,8 +0,0 @@
-// Exports from core should already be modules
-export * from './core';
-
-export * as EntityService from '../services/entity-service';
-
-export * as CoreApi from './core-api';
-export * as Utils from './utils';
-export * as Shared from './shared';

package/lib/types/shared/entity-service.d.ts

@@ -1 +0,0 @@
-export interface EntityServicePluginParams {}

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

@@ -1,3 +0,0 @@
-export * from './registries';
-export * from './entity-service';
-export * from './plugins';

package/lib/types/shared/plugins.d.ts

@@ -1,3 +0,0 @@
-export interface PluginActivation {
-  [key: keyof any]: unknown;
-}

package/lib/types/shared/registries.d.ts

@@ -1,45 +0,0 @@
-import type { Common, Schema, UID } from '@strapi/strapi';
-
-/**
- * Shared service registry
- */
-export interface Services {
-  [uid: UID.Service]: Common.Service;
-}
-
-/**
- * Shared controller registry
- */
-export interface Controllers {
-  [uid: UID.Controller]: Common.Controller;
-}
-
-/**
- * Shared policy registry
- */
-export interface Policies {
-  // TODO: Create generic policy type
-  [uid: UID.Policy]: unknown;
-}
-
-/**
- * Shared middleware registry
- */
-export interface Middlewares {
-  // TODO: Create generic middleware type
-  [uid: UID.Middleware]: unknown;
-}
-
-/**
- * Shared content-types registry
- */
-export interface ContentTypes {
-  [key: UID.ContentType]: Schema.ContentType;
-}
-
-/**
- * Shared component registry
- */
-export interface Components {
-  [key: UID.Component]: Schema.Component;
-}

package/lib/types/utils/array.d.ts

@@ -1,25 +0,0 @@
-import type { Utils } from '@strapi/strapi';
-
-/**
- * Extract the array values into an union type
- **/
-export type Values<TCollection extends Array<unknown>> = TCollection extends Array<infer TValues>
-  ? TValues
-  : never;
-
-/**
- * Checks if the size of the given collection equals 0
- */
-export type IsEmpty<TCollection extends Array<unknown>> = Utils.Expression.Extends<
-  TCollection['length'],
-  0
->;
-
-/**
- * Checks if the size of the given collection is not 0
- *
- * Returns a {@link Utils.Expression.Boolean} expression
- */
-export type IsNotEmpty<TCollection extends Array<unknown>> = Utils.Expression.Not<
-  IsEmpty<TCollection>
->;

package/lib/types/utils/expression.d.ts

@@ -1,91 +0,0 @@
-import type { Utils } from '@strapi/strapi';
-
-export type True = true;
-export type False = false;
-export type BooleanValue = True | False;
-
-export type IsNever<TValue> = StrictEqual<TValue, never>;
-
-export type IsNotNever<TValue> = Not<IsNever<TValue>>;
-
-export type IsTrue<TValue> = [TValue] extends [True] ? True : False;
-
-export type IsFalse<TValue> = [TValue] extends [False] ? True : False;
-
-export type StrictEqual<TValue, TMatch> = And<Extends<TValue, TMatch>, Extends<TMatch, TValue>>;
-
-export type Extends<TLeft, TRight> = [TLeft] extends [TRight] ? True : False;
-
-export type DoesNotExtends<TLeft, TRight> = Not<Extends<TLeft, TRight>>;
-
-export type Not<TExpression extends BooleanValue> = If<TExpression, False, True>;
-
-export type If<TExpression extends BooleanValue, TOnTrue, TOnFalse = never> = [
-  TExpression
-] extends [True]
-  ? TOnTrue
-  : TOnFalse;
-
-export type MatchFirst<TTests extends Test[], TDefault = never> = TTests extends [
-  infer THead extends Test,
-  ...infer TTail extends Test[]
-]
-  ? THead extends Test<infer TExpression, infer TValue>
-    ? If<
-        TExpression,
-        TValue,
-        If<Utils.Array.IsNotEmpty<TTail>, MatchFirst<TTail, TDefault>, TDefault>
-      >
-    : never
-  : never;
-
-export type MatchAllUnion<TTests extends Test[], TDefault = never> = TTests extends [
-  infer THead extends Test,
-  ...infer TTail extends Test[]
-]
-  ? THead extends Test<infer TExpression, infer TValue>
-    ? Utils.Guard.Never<
-        If<TExpression, TValue> | If<Utils.Array.IsNotEmpty<TTail>, MatchAllUnion<TTail, TDefault>>,
-        TDefault
-      >
-    : never
-  : never;
-
-export type MatchAllIntersect<TTests extends Test[], TDefault = unknown> = TTests extends [
-  infer THead extends Test,
-  ...infer TTail extends Test[]
-]
-  ? THead extends Test<infer TExpression, infer TValue>
-    ? // Actual test case evaluation
-      If<TExpression, TValue, TDefault> &
-        // Recursion / End of recursion
-        If<Utils.Array.IsNotEmpty<TTail>, MatchAllIntersect<TTail, TDefault>, TDefault>
-    : TDefault
-  : TDefault;
-
-export type Test<TExpression extends BooleanValue = BooleanValue, TValue = unknown> = [
-  TExpression,
-  TValue
-];
-
-export type Some<TExpressions extends BooleanValue[]> = TExpressions extends [
-  infer THead extends BooleanValue,
-  ...infer TTail extends BooleanValue[]
-]
-  ? If<Utils.Array.IsNotEmpty<TTail>, Or<THead, Some<TTail>>, Or<THead, false>>
-  : never;
-
-export type Every<TExpressions extends BooleanValue[]> = TExpressions extends [
-  infer THead extends BooleanValue,
-  ...infer TTail extends BooleanValue[]
-]
-  ? If<Utils.Array.IsNotEmpty<TTail>, And<THead, Every<TTail>>, And<THead, True>>
-  : never;
-
-export type And<TLeft extends BooleanValue, TRight extends BooleanValue> = IsTrue<
-  IsTrue<TLeft> | IsTrue<TRight>
->;
-
-export type Or<TLeft extends BooleanValue, TRight extends BooleanValue> = Not<
-  IsFalse<IsTrue<TLeft> | IsTrue<TRight>>
->;

package/lib/types/utils/guard.d.ts

@@ -1,27 +0,0 @@
-import type { Utils } from '@strapi/strapi';
-
-/**
- * Assign a default value `TDefault` to `TValue` if `TValue` is of type `never`
- *
- * @example
- * type X = Never<{ foo: 'bar' }, string>
- * // { foo: 'bar' }
- *
- * type X = Never<never>
- * // unknown
- *
- * type X = Never<never, string>
- * // string
- */
-export type Never<TValue, TFallback = unknown> = OfTypes<[never], TValue, TFallback>;
-
-export type OfTypes<TTypes extends unknown[], TValue, TFallback = unknown> = TTypes extends [
-  infer THead extends unknown,
-  ...infer TTail extends unknown[]
-]
-  ? Utils.Expression.If<
-      Utils.Expression.StrictEqual<TValue, THead>,
-      TFallback,
-      Utils.Expression.If<Utils.Array.IsNotEmpty<TTail>, OfTypes<TTail, TValue, TFallback>, TValue>
-    >
-  : never;

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

@@ -1,27 +0,0 @@
-export * as Array from './array';
-export * as Guard from './guard';
-export * as Object from './object';
-export * as String from './string';
-export * as Tuple from './tuple';
-export * as Expression from './expression';
-
-/**
- * Get the type of a specific key `TKey` in `TValue`
- *
- * @example
- *
- * type X = Get<{ foo: 'bar', 'bar': 'foo' }, 'foo'>
- * // 'bar'
- *
- * type X = Get<{ foo: 'bar', 'bar': 'foo' }, 'bar'>
- * // 'foo'
- */
-export type Get<TValue, TKey extends keyof TValue> = TValue[TKey];
-
-export type Without<TLeft, TRight> = { [key in Exclude<keyof TLeft, keyof TRight>]?: never };
-
-export type XOR<TLeft, TRight> = TLeft | TRight extends object
-  ? (Without<TLeft, TRight> & TRight) | (Without<TRight, TLeft> & TLeft)
-  : TLeft | TRight;
-
-export type Cast<TValue, TType> = TValue extends TType ? TValue : never;

package/lib/types/utils/object.d.ts

@@ -1,63 +0,0 @@
-/**
- * Retrieve object's (`TValue`) keys if they extend the given `TTest` type.
- *
- * @example
- * type X = KeysBy<{ foo: 'bar', bar: 'foo', foobar: 2 }, string>
- * // 'foo' | 'bar'
- *
- * type Base = { x: 'foo' | 'bar' };
- * type Obj = { foo: { x: 'foo' }, bar: { x: 'bar' }, other: { x: '42' } };
- * type X = KeysBy<Obj, Base>
- * // 'foo' | 'bar'
- */
-export type KeysBy<TValue, TTest> = {
-  [key in keyof TValue]: TValue[key] extends TTest ? key : never;
-}[keyof TValue];
-
-/**
- * Retrieve object's (`TValue`) keys if they don't extend the given `TTest` type.
- *
- * @example
- * type X = KeysExcept<{ foo: 'bar', bar: 'foo', foobar: 2 }, string>
- * // foobar
- *
- * type Base = { x: 'foo' | 'bar' };
- * type Obj = { foo: { x: 'foo' }, bar: { x: 'bar' }, other: { x: '42' } };
- * type X = KeysBy<Obj, Base>
- * // 'other'
- */
-export type KeysExcept<TValue, TTest> = {
-  [key in keyof TValue]: TValue[key] extends TTest ? never : key;
-}[keyof TValue];
-
-/**
- * Retrieve object's (`TValue`) properties if their value extends the given `TTest` type.
- *
- * @example
- * type X = KeysBy<{ foo: 'bar', bar: 'foo', foobar: 2 }, string>
- * // { foo: 'bar', bar: 'foo' }
- *
- * type Base = { x: 'foo' | 'bar' };
- * type Obj = { foo: { x: 'foo' }, bar: { x: 'bar' }, other: { x: '42' } };
- * type X = KeysBy<Obj, Base>
- * // { foo: { x: 'foo' }, bar: { x: 'bar' } }
- */
-export type PickBy<TValue, TTest> = Pick<TValue, KeysBy<TValue, TTest>>;
-
-/**
- * Retrieve object's (`TObject`) values
- *
- * @example
- * type X = Values<{ foo: 'bar', bar: 'foo', foobar: 2 }>
- * // 'bar' | 'foo' | 2
- *
- * type Y = Values<{ foo: { x: 'foo' }, bar: { x: 'bar' }, other: { x: '42' } }>
- * // { x: 'foo' } | { x: 'bar' } | { x: '42' }
- */
-export type Values<TObject extends object> = TObject[keyof TObject];
-
-export type DeepPartial<TObject> = TObject extends object
-  ? {
-      [TKey in keyof TObject]?: DeepPartial<TObject[TKey]>;
-    }
-  : TObject;