@strapi/strapi 4.11.0 → 4.11.1-beta.1

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

@@ -1,27 +0,0 @@
-import { Context, Next } from 'koa';
-
-type ControllerResponse<T = unknown> = T | Promise<T> | undefined;
-
-interface Controller {
-  transformResponse(data: object, meta: object): object;
-  sanitizeOutput(data: object, ctx: Context): Promise<object>;
-  sanitizeInput(data: object, ctx: Context): Promise<object>;
-}
-
-export interface SingleTypeController extends Controller {
-  find?(ctx: Context, next: Next): ControllerResponse;
-  update?(ctx: Context, next: Next): ControllerResponse;
-  delete?(ctx: Context, next: Next): ControllerResponse;
-}
-
-export interface CollectionTypeController extends Controller {
-  find?(ctx: Context, next: Next): ControllerResponse;
-  findOne?(ctx: Context, next: Next): ControllerResponse;
-  create?(ctx: Context, next: Next): ControllerResponse;
-  update?(ctx: Context, next: Next): ControllerResponse;
-  delete?(ctx: Context, next: Next): ControllerResponse;
-}
-
-export type GenericController = Partial<Controller> & {
-  [method: string | number | symbol]: (ctx: Context) => unknown;
-};

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

@@ -1,25 +0,0 @@
-type Entity = object;
-
-interface BaseService {
-  getFetchParams?(params: object): object;
-}
-
-export interface SingleTypeService extends BaseService {
-  find?(params: object): Promise<Entity> | Entity;
-  createOrUpdate?(params: object): Promise<Entity> | Entity;
-  delete?(params: object): Promise<Entity> | Entity;
-}
-
-export interface CollectionTypeService extends BaseService {
-  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;
-}
-
-export type Service = SingleTypeService | CollectionTypeService;
-
-export type GenericService = Partial<Service> & {
-  [method: string | number | symbol]: (...args: any) => any;
-};

package/lib/types/factories.d.ts

@@ -1,60 +0,0 @@
-import { Service, GenericService } from '../core-api/service';
-import { Controller, GenericController } from '../core-api/controller';
-import { Middleware } from '../middlewares';
-import { Policy } from '../core/registries/policies';
-import { Strapi } from './core/strapi';
-
-type ControllerConfig<T extends Controller = Controller> = T;
-
-type ServiceConfig = Service;
-
-type HandlerConfig = {
-  auth?: false | { scope: string[] };
-  policies?: Array<string | Policy | { name: string; config: object }>;
-  middlewares?: Array<string | Middleware | { name: string; config: object }>;
-};
-
-type SingleTypeRouterConfig = {
-  find?: HandlerConfig;
-  update?: HandlerConfig;
-  delete?: HandlerConfig;
-};
-
-type CollectionTypeRouterConfig = {
-  find?: HandlerConfig;
-  findOne?: HandlerConfig;
-  create?: HandlerConfig;
-  update?: HandlerConfig;
-  delete?: HandlerConfig;
-};
-
-type RouterConfig = {
-  prefix?: string;
-  only?: string[];
-  except?: string[];
-  config: SingleTypeRouterConfig | CollectionTypeRouterConfig;
-};
-
-interface Route {
-  method: string;
-  path: string;
-}
-interface Router {
-  prefix: string;
-  routes: Route[];
-}
-
-type ControllerCallback<T extends GenericController = GenericController> = (params: {
-  strapi: Strapi;
-}) => T;
-type ServiceCallback<T extends GenericService = GenericService> = (params: { strapi: Strapi }) => T;
-
-export function createCoreRouter(uid: string, cfg?: RouterConfig = {}): () => Router;
-export function createCoreController<T extends GenericController = GenericController>(
-  uid: string,
-  cfg?: ControllerCallback<T> | T = {}
-): () => T & Controller;
-export function createCoreService<T extends GenericService = GenericService>(
-  uid: string,
-  cfg?: ServiceCallback<T> | T = {}
-): () => T;

package/lib/types/utils.d.ts

@@ -1,95 +0,0 @@
-/**
- *
- * Common utilities used across Strapi typings
- *
- * */
-
-/**
- *
- * Extract the array values into an union type
- *
- **/
-export type GetArrayValues<T extends Array<unknown>> = T extends Array<infer U> ? U : never;
-
-/**
- * Creates a record where every key is a string and every value is `T`
- */
-export type StringRecord<T> = Record<string, T>;
-
-/**
- * Retrieve object's (`T`) keys if they extends the given `U` 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<T, U> = {
-  [key in keyof T]: T[key] extends U ? key : never;
-}[keyof T];
-
-/**
- * Retrieve object's (`T`) properties if their value extends the given `U` 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<T, U> = Pick<T, KeysBy<T, U>>;
-
-/**
- * Assign a default value `U` to `T` if `T` is of type `never`
- *
- * @example
- * type X = NeverGuard<{ foo: 'bar' }, string>
- * // { foo: 'bar' }
- *
- * type X = NeverGuard<never>
- * // unknown
- *
- * type X = NeverGuard<never, string>
- * // string
- */
-export type NeverGuard<T, U = unknown> = [T] extends [never] ? U : T;
-
-/**
- * Dynamic type based on the keys of `Strapi.Schemas`.
- * It represents all the registered schemas' UID as a union type.
- *
- * @example
- *
- * declare global {
- *   namespace Strapi {
- *     interface Schemas {
- *       'api::foo.foo': CollectionTypeSchema;
- *       'api::bar.bar': ComponentSchema;
- *     }
- *   }
- * }
- *
- * type X = SchemaUID;
- * // 'api::foo.foo' | 'api::bar.bar'
- */
-export type SchemaUID = keyof Strapi.Schemas;
-
-/**
- * Get the type of a specific key `U` in `T`
- *
- * @example
- *
- * type X = Get<{ foo: 'bar', 'bar': 'foo' }, 'foo'>
- * // 'bar'
- *
- * type X = Get<{ foo: 'bar', 'bar': 'foo' }, 'bar'>
- * // 'foo'
- */
-export type Get<T, U extends keyof T> = T[U];