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

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 {
@@ -21,7 +17,7 @@ interface CustomFieldServerOptions {
    * The existing Strapi data type the custom field uses
    */
   type: string;
-  
+
   /**
    * Settings for the input size in the Admin UI
    */
@@ -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

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

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

@@ -0,0 +1,52 @@
+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>(data: TData, ctx: ExtendableContext): Promise<TData>;
+}
+
+/**
+ * Generic controller structure
+ */
+export type Generic = {
+  [name: string]: Common.ControllerHandler<unknown>;
+};
+
+/**
+ * Core-API collection type controller
+ */
+export interface CollectionType extends Base {
+  find?: Common.ControllerHandler<unknown>;
+  findOne?: Common.ControllerHandler<unknown>;
+  create?: Common.ControllerHandler<unknown>;
+  update?: Common.ControllerHandler<unknown>;
+  delete?: Common.ControllerHandler<unknown>;
+}
+
+/**
+ * Core-API single type controller
+ */
+export interface SingleType extends Base {
+  find?: Common.ControllerHandler<unknown>;
+  update?: Common.ControllerHandler<unknown>;
+  delete?: Common.ControllerHandler<unknown>;
+}
+
+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

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

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

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

@@ -0,0 +1,48 @@
+import type { Common, Utils } from '@strapi/strapi';
+
+// TODO Use actual entities instead of regular object
+type Entity = object;
+
+/**
+ * Base Core-API service type
+ */
+export interface Base {
+  getFetchParams?(params: object): object;
+}
+
+/**
+ * Generic service structure
+ */
+export type Generic = {
+  [method: string | number | symbol]: (...args: any) => any;
+};
+
+/**
+ * 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,4 +1,6 @@
+// Exports from core should already be modules
 export * from './core';
 
-export * as utils from './utils';
-export * as factories from './factories';
+export * as CoreApi from './core-api';
+export * as Utils from './utils';
+export * as Shared from './shared';

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

@@ -0,0 +1 @@
+export * from './registries';

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

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

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