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

package/lib/commands/actions/develop/action.js

@@ -121,13 +121,12 @@ const workerProcess = async ({ appDir, distDir, watchAdmin, polling, isTSProject
   const shouldGenerateTypeScriptTypes = strapiInstance.config.get('typescript.autogenerate', false);
 
   if (shouldGenerateTypeScriptTypes) {
-    // This is run in an uncaught promise on purpose so that it doesn't block Strapi startup
-    // NOTE: We should probably add some configuration options to manage the file structure output or the verbosity level
-    tsUtils.generators.generateSchemasDefinitions({
+    await tsUtils.generators.generate({
       strapi: strapiInstance,
-      outDir: appDir,
-      verbose: false,
-      silent: true,
+      pwd: appDir,
+      rootDir: undefined,
+      logger: { silent: true, debug: false },
+      artifacts: { contentTypes: true, components: true },
     });
   }
 

package/lib/commands/actions/ts/generate-types/action.js

@@ -4,22 +4,25 @@ const tsUtils = require('@strapi/typescript-utils');
 
 const strapi = require('../../../../index');
 
-module.exports = async ({ outDir, file, verbose, silent }) => {
-  if (verbose && silent) {
-    console.error('You cannot enable verbose and silent flags at the same time, exiting...');
+module.exports = async ({ debug, silent, verbose, outDir }) => {
+  if ((debug || verbose) && silent) {
+    console.error('Flags conflict: both silent and debug mode are enabled, exiting...');
     process.exit(1);
   }
 
   const appContext = await strapi.compile();
   const app = await strapi(appContext).register();
 
-  await tsUtils.generators.generateSchemasDefinitions({
+  await tsUtils.generators.generate({
     strapi: app,
-    outDir: outDir || appContext.appDir,
-    file,
-    dirs: appContext,
-    verbose,
-    silent,
+    pwd: appContext.appDir,
+    rootDir: outDir ?? undefined,
+    logger: {
+      silent,
+      // TODO V5: verbose is deprecated and should be removed
+      debug: debug || verbose,
+    },
+    artifacts: { contentTypes: true, components: true },
   });
 
   app.destroy();

package/lib/commands/actions/ts/generate-types/command.js

@@ -10,12 +10,12 @@ module.exports = ({ command }) => {
   command
     .command('ts:generate-types')
     .description(`Generate TypeScript typings for your schemas`)
+    .option('--verbose', `[DEPRECATED] The verbose option has been replaced by debug`, false)
+    .option('-d, --debug', `Run the generation with debug messages`, false)
+    .option('-s, --silent', `Run the generation silently, without any output`, false)
     .option(
       '-o, --out-dir <outDir>',
-      'Specify a relative directory in which the schemas definitions will be generated'
+      'Specify a relative root directory in which the definitions will be generated. Changing this value might break types exposed by Strapi that relies on generated types.'
     )
-    .option('-f, --file <file>', 'Specify a filename to store the schemas definitions')
-    .option('--verbose', `Display more information about the types generation`, false)
-    .option('-s, --silent', `Run the generation silently, without any output`, false)
     .action(getLocalScript('ts/generate-types'));
 };

package/lib/core/domain/content-type/index.js

@@ -2,7 +2,7 @@
 
 const { cloneDeep } = require('lodash/fp');
 const _ = require('lodash');
-const { hasDraftAndPublish, getPrivateAttributes } = require('@strapi/utils').contentTypes;
+const { hasDraftAndPublish } = require('@strapi/utils').contentTypes;
 const {
   CREATED_AT_ATTRIBUTE,
   UPDATED_AT_ATTRIBUTE,
@@ -58,12 +58,6 @@ const createContentType = (uid, definition) => {
     );
   }
 
-  Object.defineProperty(schema, 'privateAttributes', {
-    get() {
-      return getPrivateAttributes(schema);
-    },
-  });
-
   // attributes
   Object.assign(schema.attributes, {
     [CREATED_AT_ATTRIBUTE]: {

package/lib/factories.d.ts

@@ -0,0 +1,21 @@
+import type { Common, CoreApi, Strapi } from '@strapi/strapi';
+
+type WithStrapiCallback<T> = <S extends { strapi: Strapi }>(params: S) => T;
+
+export declare function createCoreRouter<T extends Common.UID.ContentType>(
+  uid: T,
+  cfg?: CoreApi.Router.RouterConfig<T>
+): () => CoreApi.Router.Router;
+
+export declare function createCoreController<
+  T extends Common.UID.ContentType,
+  S extends Partial<CoreApi.Controller.Extendable<T>>
+>(
+  uid: T,
+  config?: WithStrapiCallback<S> | S
+): () => Required<S & CoreApi.Controller.ContentType<T>>;
+
+export declare function createCoreService<
+  T extends Common.UID.ContentType,
+  S extends Partial<CoreApi.Service.Extendable<T>>
+>(uid: T, config?: WithStrapiCallback<S> | S): () => Required<S & CoreApi.Service.ContentType<T>>;

package/lib/global.d.ts

@@ -1,51 +1,7 @@
 import type { Strapi as StrapiInterface } from './types/core';
-import type {
-  CollectionTypeSchema,
-  SingleTypeSchema,
-  ComponentSchema,
-  ContentTypeSchema,
-} from './types/core/schemas';
-import type { KeysBy } from './types/utils';
 
 declare global {
   namespace Strapi {
-    /**
-     * Map of UID / schemas used as a schemas database for other types.
-     * It must be extended by the user application or plugins.
-     *
-     * @example
-     * ```ts
-     * declare global {
-     *   namespace Strapi {
-     *     interface Schemas {
-     *       'xxx::xxx.uid: ContentTypeSchema | ComponentSchema;
-     *     }
-     *   }
-     * }
-     * ```
-     */
-    interface Schemas {}
-
-    /**
-     * Literal union type of every content type registered in Strapi.Schemas
-     */
-    type ContentTypeUIDs = KeysBy<Schemas, ContentTypeSchema>;
-
-    /**
-     * Literal union type of every collection type registered in Strapi.Schemas
-     */
-    type CollectionTypeUIDs = KeysBy<Schemas, CollectionTypeSchema>;
-
-    /**
-     * Literal union type of every single type registered in Strapi.Schemas
-     */
-    type SingleTypeUIDs = KeysBy<Schemas, SingleTypeSchema>;
-
-    /**
-     * Literal union type of every component registered in Strapi.Schemas
-     */
-    type ComponentUIDs = KeysBy<Schemas, ComponentSchema>;
-
     /**
      * Global shorthand to access the `StrapiInterface` type
      */

package/lib/index.d.ts

@@ -1,5 +1,6 @@
 import './global';
 
 export * from './types';
+export * as factories from './factories';
 
-export default function (opts): Strapi;
+export default function (opts): Strapi.Strapi;

package/lib/services/entity-service/index.d.ts

@@ -1,8 +1,6 @@
-import { Database } from '@strapi/database';
+import type { Database, ID } from '@strapi/database';
 import { Strapi } from '../../';
 
-type ID = number | string;
-
 type EntityServiceAction =
   | 'findMany'
   | 'findPage'

package/lib/services/entity-service/index.js

@@ -4,11 +4,7 @@ const _ = require('lodash');
 const delegate = require('delegates');
 const { InvalidTimeError, InvalidDateError, InvalidDateTimeError, InvalidRelationError } =
   require('@strapi/database').errors;
-const {
-  webhook: webhookUtils,
-  contentTypes: contentTypesUtils,
-  sanitize,
-} = require('@strapi/utils');
+const { contentTypes: contentTypesUtils, sanitize } = require('@strapi/utils');
 const { ValidationError } = require('@strapi/utils').errors;
 const { isAnyToMany } = require('@strapi/utils').relations;
 const { transformParamsToQuery } = require('@strapi/utils').convertQueryParams;
@@ -31,9 +27,6 @@ const transformLoadParamsToQuery = (uid, field, params = {}, pagination = {}) =>
   };
 };
 
-// TODO: those should be strapi events used by the webhooks not the other way arround
-const { ENTRY_CREATE, ENTRY_UPDATE, ENTRY_DELETE } = webhookUtils.webhookEvents;
-
 const databaseErrorsToTransform = [
   InvalidTimeError,
   InvalidDateTimeError,
@@ -49,6 +42,12 @@ const updatePipeline = (data, context) => {
   return applyTransforms(data, context);
 };
 
+const ALLOWED_WEBHOOK_EVENTS = {
+  ENTRY_CREATE: 'entry.create',
+  ENTRY_UPDATE: 'entry.update',
+  ENTRY_DELETE: 'entry.delete',
+};
+
 /**
  * @type {import('.').default}
  */
@@ -59,6 +58,10 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
     return options;
   },
 
+  async wrapResult(result) {
+    return result;
+  },
+
   async emitEvent(uid, event, entity) {
     // Ignore audit log events to prevent infinite loops
     if (uid === 'admin::audit-log') {
@@ -83,10 +86,12 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
     const query = transformParamsToQuery(uid, wrappedParams);
 
     if (kind === 'singleType') {
-      return db.query(uid).findOne(query);
+      const entity = db.query(uid).findOne(query);
+      return this.wrapResult(entity, { uid, action: 'findOne' });
     }
 
-    return db.query(uid).findMany(query);
+    const entities = await db.query(uid).findMany(query);
+    return this.wrapResult(entities, { uid, action: 'findMany' });
   },
 
   async findPage(uid, opts) {
@@ -94,7 +99,11 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
 
     const query = transformParamsToQuery(uid, wrappedParams);
 
-    return db.query(uid).findPage(query);
+    const page = await db.query(uid).findPage(query);
+    return {
+      ...page,
+      results: await this.wrapResult(page.results, { uid, action: 'findPage' }),
+    };
   },
 
   // TODO: streamline the logic based on the populate option
@@ -103,7 +112,11 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
 
     const query = transformParamsToQuery(uid, wrappedParams);
 
-    return db.query(uid).findPage(query);
+    const entities = await db.query(uid).findPage(query);
+    return {
+      ...entities,
+      results: await this.wrapResult(entities.results, { uid, action: 'findWithRelationCounts' }),
+    };
   },
 
   async findWithRelationCounts(uid, opts) {
@@ -111,7 +124,8 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
 
     const query = transformParamsToQuery(uid, wrappedParams);
 
-    return db.query(uid).findMany(query);
+    const entities = await db.query(uid).findMany(query);
+    return this.wrapResult(entities, { uid, action: 'findWithRelationCounts' });
   },
 
   async findOne(uid, entityId, opts) {
@@ -119,7 +133,8 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
 
     const query = transformParamsToQuery(uid, pickSelectionParams(wrappedParams));
 
-    return db.query(uid).findOne({ ...query, where: { id: entityId } });
+    const entity = await db.query(uid).findOne({ ...query, where: { id: entityId } });
+    return this.wrapResult(entity, { uid, action: 'findOne' });
   },
 
   async count(uid, opts) {
@@ -162,6 +177,9 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
       entity = await this.findOne(uid, entity.id, wrappedParams);
     }
 
+    entity = await this.wrapResult(entity, { uid, action: 'create' });
+
+    const { ENTRY_CREATE } = ALLOWED_WEBHOOK_EVENTS;
     await this.emitEvent(uid, ENTRY_CREATE, entity);
 
     return entity;
@@ -213,6 +231,9 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
       entity = await this.findOne(uid, entity.id, wrappedParams);
     }
 
+    entity = await this.wrapResult(entity, { uid, action: 'update' });
+
+    const { ENTRY_UPDATE } = ALLOWED_WEBHOOK_EVENTS;
     await this.emitEvent(uid, ENTRY_UPDATE, entity);
 
     return entity;
@@ -224,7 +245,7 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
     // select / populate
     const query = transformParamsToQuery(uid, pickSelectionParams(wrappedParams));
 
-    const entityToDelete = await db.query(uid).findOne({
+    let entityToDelete = await db.query(uid).findOne({
       ...query,
       where: { id: entityId },
     });
@@ -238,6 +259,9 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
     await db.query(uid).delete({ where: { id: entityToDelete.id } });
     await deleteComponents(uid, componentsToDelete, { loadComponents: false });
 
+    entityToDelete = await this.wrapResult(entityToDelete, { uid, action: 'delete' });
+
+    const { ENTRY_DELETE } = ALLOWED_WEBHOOK_EVENTS;
     await this.emitEvent(uid, ENTRY_DELETE, entityToDelete);
 
     return entityToDelete;
@@ -250,7 +274,7 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
     // select / populate
     const query = transformParamsToQuery(uid, wrappedParams);
 
-    const entitiesToDelete = await db.query(uid).findMany(query);
+    let entitiesToDelete = await db.query(uid).findMany(query);
 
     if (!entitiesToDelete.length) {
       return null;
@@ -265,21 +289,28 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
       componentsToDelete.map((compos) => deleteComponents(uid, compos, { loadComponents: false }))
     );
 
+    entitiesToDelete = await this.wrapResult(entitiesToDelete, { uid, action: 'delete' });
+
     // Trigger webhooks. One for each entity
+    const { ENTRY_DELETE } = ALLOWED_WEBHOOK_EVENTS;
     await Promise.all(entitiesToDelete.map((entity) => this.emitEvent(uid, ENTRY_DELETE, entity)));
 
     return deletedEntities;
   },
 
-  load(uid, entity, field, params = {}) {
+  async load(uid, entity, field, params = {}) {
     if (!_.isString(field)) {
       throw new Error(`Invalid load. Expected "${field}" to be a string`);
     }
 
-    return db.query(uid).load(entity, field, transformLoadParamsToQuery(uid, field, params));
+    const loadedEntity = await db
+      .query(uid)
+      .load(entity, field, transformLoadParamsToQuery(uid, field, params));
+
+    return this.wrapResult(loadedEntity, { uid, field, action: 'load' });
   },
 
-  loadPages(uid, entity, field, params = {}, pagination = {}) {
+  async loadPages(uid, entity, field, params = {}, pagination = {}) {
     if (!_.isString(field)) {
       throw new Error(`Invalid load. Expected "${field}" to be a string`);
     }
@@ -293,11 +324,20 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
 
     const query = transformLoadParamsToQuery(uid, field, params, pagination);
 
-    return db.query(uid).loadPages(entity, field, query);
+    const loadedPage = await db.query(uid).loadPages(entity, field, query);
+
+    return {
+      ...loadedPage,
+      results: await this.wrapResult(loadedPage.results, { uid, field, action: 'load' }),
+    };
   },
 });
 
 module.exports = (ctx) => {
+  Object.entries(ALLOWED_WEBHOOK_EVENTS).forEach(([key, value]) => {
+    ctx.strapi.webhookStore.addAllowedEvent(key, value);
+  });
+
   const implementation = createDefaultImplementation(ctx);
 
   const service = {

package/lib/services/webhook-store.js

@@ -4,6 +4,9 @@
 
 'use strict';
 
+const { mapAsync } = require('@strapi/utils');
+const { ValidationError } = require('@strapi/utils').errors;
+
 const webhookModel = {
   uid: 'webhook',
   collectionName: 'strapi_webhooks',
@@ -47,30 +50,56 @@ const fromDBObject = (row) => {
   };
 };
 
+const webhookEventValidator = async (allowedEvents, events) => {
+  const allowedValues = Array.from(allowedEvents.values());
+
+  await mapAsync(events, (event) => {
+    if (allowedValues.includes(event)) {
+      return;
+    }
+
+    throw new ValidationError(`Webhook event ${event} is not supported`);
+  });
+};
+
 const createWebhookStore = ({ db }) => {
   const webhookQueries = db.query('webhook');
 
   return {
+    allowedEvents: new Map([]),
+    addAllowedEvent(key, value) {
+      this.allowedEvents.set(key, value);
+    },
+    removeAllowedEvent(key) {
+      this.allowedEvents.delete(key);
+    },
+    listAllowedEvents() {
+      return Array.from(this.allowedEvents.keys());
+    },
+    getAllowedEvent(key) {
+      return this.allowedEvents.get(key);
+    },
     async findWebhooks() {
       const results = await webhookQueries.findMany();
 
       return results.map(fromDBObject);
     },
-
     async findWebhook(id) {
       const result = await webhookQueries.findOne({ where: { id } });
       return result ? fromDBObject(result) : null;
     },
+    async createWebhook(data) {
+      await webhookEventValidator(this.allowedEvents, data.events);
 
-    createWebhook(data) {
       return webhookQueries
         .create({
           data: toDBObject({ ...data, isEnabled: true }),
         })
         .then(fromDBObject);
     },
-
     async updateWebhook(id, data) {
+      await webhookEventValidator(this.allowedEvents, data.events);
+
       const webhook = await webhookQueries.update({
         where: { id },
         data: toDBObject(data),
@@ -78,7 +107,6 @@ const createWebhookStore = ({ db }) => {
 
       return webhook ? fromDBObject(webhook) : null;
     },
-
     async deleteWebhook(id) {
       const webhook = await webhookQueries.delete({ where: { id } });
       return webhook ? fromDBObject(webhook) : null;

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

@@ -1,9 +1,7 @@
-import { GetAttributeValue } from './utils';
-
 /**
  * List of all the Strapi attribute types
  */
-export type AttributeType =
+export type Kind =
   | 'string'
   | 'text'
   | 'richtext'
@@ -29,11 +27,11 @@ export type AttributeType =
 /**
  * Most basic shape of a schema attribute
  */
-export interface Attribute<T extends AttributeType = AttributeType> {
+export interface Attribute<TKind extends Kind = Kind> {
   /**
    * Type of the attribute
    */
-  type: T;
+  type: TKind;
 
   /**
    * Options defined and used by the plugins
@@ -41,6 +39,11 @@ export interface Attribute<T extends AttributeType = AttributeType> {
   pluginOptions?: object;
 }
 
+/**
+ * Creates a basic Attribute of type T
+ */
+export type OfType<T extends Kind> = Attribute<T>;
+
 // Common attributes Options
 
 export interface RequiredOption {

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

@@ -1,22 +1,15 @@
-import {
-  Attribute,
-  ConfigurableOption,
-  DefaultOption,
-  MinMaxOption,
-  PrivateOption,
-  RequiredOption,
-} from './base';
+import type { Attribute } from '@strapi/strapi';
 
-export type BigIntegerAttribute = Attribute<'biginteger'> &
+export type BigInteger = Attribute.OfType<'biginteger'> &
   // Options
-  ConfigurableOption &
-  DefaultOption<BigIntegerValue> &
-  MinMaxOption<string> &
-  PrivateOption &
-  RequiredOption;
+  Attribute.ConfigurableOption &
+  Attribute.DefaultOption<BigIntegerValue> &
+  Attribute.MinMaxOption<string> &
+  Attribute.PrivateOption &
+  Attribute.RequiredOption;
 
 export type BigIntegerValue = string;
 
-export type GetBigIntegerAttributeValue<T extends Attribute> = T extends BigIntegerAttribute
+export type GetBigIntegerValue<T extends Attribute.Attribute> = T extends BigInteger
   ? BigIntegerValue
   : never;

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

@@ -1,20 +1,14 @@
-import {
-  Attribute,
-  ConfigurableOption,
-  DefaultOption,
-  PrivateOption,
-  RequiredOption,
-} from './base';
+import type { Attribute } from '@strapi/strapi';
 
-export type BooleanAttribute = Attribute<'boolean'> &
+export type Boolean = Attribute.OfType<'boolean'> &
   // Options
-  ConfigurableOption &
-  DefaultOption<BooleanValue> &
-  PrivateOption &
-  RequiredOption;
+  Attribute.ConfigurableOption &
+  Attribute.DefaultOption<BooleanValue> &
+  Attribute.PrivateOption &
+  Attribute.RequiredOption;
 
 export type BooleanValue = boolean;
 
-export type GetBooleanAttributeValue<T extends Attribute> = T extends BooleanAttribute
+export type GetBooleanValue<T extends Attribute.Attribute> = T extends Boolean
   ? BooleanValue
   : never;

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

@@ -2,47 +2,73 @@
  * Strapi custom scalar types
  */
 
-import { MinMaxLengthOption, MinMaxOption } from './base';
-import { StringAttribute } from './string';
-
-export type JSON<T extends object = object> = T;
-
-export type Media = any;
+import { Attribute, Common } from '@strapi/strapi';
 
 /**
  * Setters for the attributes options
  */
 
 // required
-export type RequiredAttribute = { required: true };
-export type NonRequiredAttribute = { required: false };
+export type Required = { required: true };
+export type NonRequired = { required: false };
 
 // private
-export type PrivateAttribute = { private: true };
-export type NonPrivateAttribute = { private: false };
+export type Private = { private: true };
+export type NonPrivate = { private: false };
 
 // unique
-export type UniqueAttribute = { unique: true };
-export type NonUniqueAttribute = { unique: false };
+export type Unique = { unique: true };
+export type NonUnique = { unique: false };
 
 // configurable
-export type ConfigurableAttribute = { configurable: true };
-export type NonConfigurableAttribute = { configurable: false };
+export type Configurable = { configurable: true };
+export type NonConfigurable = { configurable: false };
 
 // custom field
-export type CustomField<T extends string, P extends object = undefined> = {
-  customField: T;
-  options?: P;
+export type CustomField<TKind extends string, TOptions extends object | undefined = undefined> = {
+  customField: TKind;
+  options?: TOptions;
 };
 
 // min/max
-export type SetMinMax<T extends MinMaxOption<U>, U = number> = T;
+export type SetMinMax<TConfig extends Attribute.MinMaxOption<TType>, TType = number> = TConfig;
 
 // minLength/maxLength
-export type SetMinMaxLength<T extends MinMaxLengthOption> = T;
+export type SetMinMaxLength<TConfig extends Attribute.MinMaxLengthOption> = TConfig;
 
 // pluginOptions
-export type SetPluginOptions<T extends object = object> = { pluginOptions?: T };
+export type SetPluginOptions<TConfig extends object = object> = { pluginOptions?: TConfig };
 
 // default
 export type DefaultTo<T> = { default: T };
+
+// Any Attribute
+export type Any =
+  | Attribute.BigInteger
+  | Attribute.Boolean
+  | Attribute.Component<Common.UID.Component, boolean>
+  | Attribute.DateTime
+  | Attribute.Date
+  | Attribute.Decimal
+  | Attribute.DynamicZone
+  | Attribute.Email
+  | Attribute.Enumeration<string[]>
+  | Attribute.Float
+  | Attribute.Integer
+  | Attribute.JSON
+  | Attribute.Media<Attribute.MediaKind | undefined, boolean>
+  | Attribute.Password
+  | (
+      | Attribute.Relation<
+          Common.UID.Schema,
+          Attribute.RelationKind.BiDirectional,
+          Common.UID.Schema
+        >
+      | Attribute.Relation<Common.UID.Schema, Attribute.RelationKind.UniDirectional>
+    )
+  | Attribute.RichText
+  | Attribute.String
+  | Attribute.Text
+  | Attribute.Time
+  | Attribute.Timestamp
+  | Attribute.UID<Common.UID.Schema | undefined>;