@strapi/strapi 4.3.0-beta.1 → 4.3.1

package/bin/strapi.js

@@ -231,7 +231,25 @@ program
 //    `$ strapi opt-out-telemetry`
 program
   .command('telemetry:disable')
-  .description('Stop Strapi from sending anonymous telemetry and metadata')
+  .description('Disable anonymous telemetry and metadata sending to Strapi analytics')
   .action(getLocalScript('opt-out-telemetry'));
 
+//    `$ strapi opt-in-telemetry`
+program
+  .command('telemetry:enable')
+  .description('Enable anonymous telemetry and metadata sending to Strapi analytics')
+  .action(getLocalScript('opt-in-telemetry'));
+
+program
+  .command('ts:generate-types')
+  .description(`Generate TypeScript typings for your schemas`)
+  .option(
+    '-o, --out-dir <outDir>',
+    'Specify a relative directory in which the schemas definitions will be generated'
+  )
+  .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'));
+
 program.parseAsync(process.argv);

package/lib/Strapi.js

@@ -405,8 +405,10 @@ class Strapi {
       entityValidator: this.entityValidator,
     });
 
-    const cronTasks = this.config.get('server.cron.tasks', {});
-    this.cron.add(cronTasks);
+    if (strapi.config.get('server.cron.enabled', true)) {
+      const cronTasks = this.config.get('server.cron.tasks', {});
+      this.cron.add(cronTasks);
+    }
 
     this.telemetry.bootstrap();
 

package/lib/commands/opt-in-telemetry.js

@@ -0,0 +1,100 @@
+'use strict';
+
+const { resolve } = require('path');
+const fse = require('fs-extra');
+const chalk = require('chalk');
+const fetch = require('node-fetch');
+const { v4: uuidv4 } = require('uuid');
+const machineID = require('../utils/machine-id');
+
+const readPackageJSON = async path => {
+  try {
+    const packageObj = await fse.readJson(path);
+    return packageObj;
+  } catch (err) {
+    console.error(`${chalk.red('Error')}: ${err.message}`);
+  }
+};
+
+const writePackageJSON = async (path, file, spacing) => {
+  try {
+    await fse.writeJson(path, file, { spaces: spacing });
+    return true;
+  } catch (err) {
+    console.error(`${chalk.red('Error')}: ${err.message}`);
+    console.log(
+      `${chalk.yellow(
+        'Warning'
+      )}: There has been an error, please set "telemetryDisabled": false in the "strapi" object of your package.json manually.`
+    );
+    return false;
+  }
+};
+
+const generateNewPackageJSON = packageObj => {
+  if (!packageObj.strapi) {
+    return {
+      ...packageObj,
+      strapi: {
+        uuid: uuidv4(),
+        telemetryDisabled: false,
+      },
+    };
+  } else {
+    return {
+      ...packageObj,
+      strapi: {
+        ...packageObj.strapi,
+        uuid: packageObj.strapi.uuid ? packageObj.strapi.uuid : uuidv4(),
+        telemetryDisabled: false,
+      },
+    };
+  }
+};
+
+const sendEvent = async uuid => {
+  try {
+    await fetch('https://analytics.strapi.io/track', {
+      method: 'POST',
+      body: JSON.stringify({
+        event: 'didOptInTelemetry',
+        uuid,
+        deviceId: machineID(),
+      }),
+      headers: { 'Content-Type': 'application/json' },
+    });
+  } catch (e) {
+    //...
+  }
+};
+
+module.exports = async function optInTelemetry() {
+  const packageJSONPath = resolve(process.cwd(), 'package.json');
+  const exists = await fse.pathExists(packageJSONPath);
+
+  if (!exists) {
+    console.log(`${chalk.yellow('Warning')}: could not find package.json`);
+    process.exit(0);
+  }
+
+  const packageObj = await readPackageJSON(packageJSONPath);
+
+  if (packageObj.strapi && packageObj.strapi.uuid) {
+    if (packageObj.strapi.telemetryDisabled === false) {
+      console.log(`${chalk.yellow('Warning:')} telemetry is already enabled`);
+      process.exit(0);
+    }
+  }
+
+  const updatedPackageJSON = generateNewPackageJSON(packageObj);
+
+  const write = await writePackageJSON(packageJSONPath, updatedPackageJSON, 2);
+
+  if (!write) {
+    process.exit(0);
+  }
+
+  await sendEvent(updatedPackageJSON.strapi.uuid);
+  console.log(`${chalk.green('Successfully opted into and enabled Strapi telemetry')}`);
+  process.exit(0);
+};

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

@@ -0,0 +1,26 @@
+'use strict';
+
+const tsUtils = require('@strapi/typescript-utils');
+
+const strapi = require('../../index');
+
+module.exports = async function({ outDir, file, verbose, silent }) {
+  if (verbose && silent) {
+    console.error('You cannot enable verbose and silent flags at the same time, exiting...');
+    process.exit(1);
+  }
+
+  const appContext = await strapi.compile();
+  const app = await strapi(appContext).register();
+
+  await tsUtils.generators.generateSchemasDefinitions({
+    strapi: app,
+    outDir: outDir || appContext.appDir,
+    file,
+    dirs: appContext,
+    verbose,
+    silent,
+  });
+
+  app.destroy();
+};

package/lib/core/app-configuration/config-loader.js

@@ -4,12 +4,14 @@ const path = require('path');
 const fs = require('fs');
 const loadFile = require('./load-config-file');
 
+const VALID_EXTENSIONS = ['.js', '.json'];
+
 module.exports = dir => {
   if (!fs.existsSync(dir)) return {};
 
   return fs
     .readdirSync(dir, { withFileTypes: true })
-    .filter(file => file.isFile())
+    .filter(file => file.isFile() && VALID_EXTENSIONS.includes(path.extname(file.name)))
     .reduce((acc, file) => {
       const key = path.basename(file.name, path.extname(file.name));
 

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

@@ -1,7 +1,7 @@
 'use strict';
 
 const _ = require('lodash');
-const { yup, toRegressedEnumValue, startsWithANumber } = require('@strapi/utils');
+const { yup, toRegressedEnumValue } = require('@strapi/utils');
 
 const LIFECYCLES = [
   'beforeCreate',
@@ -24,6 +24,20 @@ const LIFECYCLES = [
   'afterDeleteMany',
 ];
 
+/**
+ * For enumerations the least common denomiator is GraphQL, where
+ * values needs to match the secure name regex:
+ * GraphQL Spec https://spec.graphql.org/June2018/#sec-Names
+ *
+ * Therefore we need to make sure our users only use values, which
+ * can be returned by GraphQL, by checking the regressed values
+ * agains the GraphQL regex.
+ *
+ * TODO V5: check if we can avoid this coupling by moving this logic
+ * into the GraphQL plugin.
+ */
+const GRAPHQL_ENUM_REGEX = new RegExp('^[_A-Za-z][_0-9A-Za-z]*$');
+
 const lifecyclesShape = _.mapValues(_.keyBy(LIFECYCLES), () =>
   yup
     .mixed()
@@ -54,22 +68,29 @@ const contentTypeSchemaValidator = yup.object().shape({
         for (const attrName in attributes) {
           const attr = attributes[attrName];
           if (attr.type === 'enumeration') {
-            // should not start by a number
-            if (attr.enum.some(startsWithANumber)) {
-              const message = `Enum values should not start with a number. Please modify your enumeration '${attrName}'.`;
+            const regressedValues = attr.enum.map(toRegressedEnumValue);
+
+            // should match the GraphQL regex
+            if (!regressedValues.every(value => GRAPHQL_ENUM_REGEX.test(value))) {
+              const message = `Invalid enumeration value. Values should have at least one alphabetical character preceeding the first occurence of a number. Update your enumeration '${attrName}'.`;
 
               return this.createError({ message });
             }
 
+            // should not contain empty values
+            if (regressedValues.some(value => value === '')) {
+              return this.createError({
+                message: `At least one value of the enumeration '${attrName}' appears to be empty. Only alphanumerical characters are taken into account.`,
+              });
+            }
+
             // should not collide
             const duplicates = _.uniq(
-              attr.enum
-                .map(toRegressedEnumValue)
-                .filter((value, index, values) => values.indexOf(value) !== index)
+              regressedValues.filter((value, index, values) => values.indexOf(value) !== index)
             );
 
             if (duplicates.length) {
-              const message = `Some enum values of the field '${attrName}' collide when normalized: ${duplicates.join(
+              const message = `Some enumeration values of the field '${attrName}' collide when normalized: ${duplicates.join(
                 ', '
               )}. Please modify your enumeration.`;
 

package/lib/global.d.ts

@@ -0,0 +1,61 @@
+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
+      */
+     type Strapi = StrapiInterface;
+  }
+
+  /**
+   * Strapi global variable definition
+   **/
+  export const strapi: StrapiInterface;
+
+  /**
+   * Adds the strapi global variable to the NodeJS Global interface
+   */
+  export interface Global {
+    strapi: StrapiInterface;
+  }
+}

package/lib/index.d.ts

@@ -1,28 +1,5 @@
-import { Database } from '@strapi/database';
-import { EntityService } from './services/entity-service';
+import './global';
 
-import * as Core from './types/strapi';
-export * as factories from './factories';
-
-export type { Core };
-
-// Alias to resolve the Strapi global type easily
-export type Strapi = Core.Strapi;
-
-export interface StrapiInterface extends Core.Strapi {};
-
-declare global {
-  interface AllTypes {}
-}
-
-declare global {
-  export interface Global {
-    strapi: StrapiInterface;
-  }
-
-  export type Strapi = StrapiInterface;
-
-  const strapi: StrapiInterface;
-}
+export * from './types';
 
 export default function(opts): Strapi;

package/lib/services/cron.js

@@ -5,6 +5,7 @@ const { isFunction } = require('lodash/fp');
 
 const createCronService = () => {
   let jobsSpecs = [];
+  let running = false;
 
   return {
     add(tasks = {}) {
@@ -29,18 +30,21 @@ const createCronService = () => {
 
         const job = new Job(null, fnWithStrapi);
         jobsSpecs.push({ job, options });
+
+        if (running) {
+          job.schedule(options);
+        }
       }
       return this;
     },
     start() {
-      if (!strapi.config.get('server.cron.enabled')) {
-        return;
-      }
       jobsSpecs.forEach(({ job, options }) => job.schedule(options));
+      running = true;
       return this;
     },
     stop() {
       jobsSpecs.forEach(({ job }) => job.cancel());
+      running = false;
       return this;
     },
     destroy() {

package/lib/services/webhook-runner.js

@@ -29,7 +29,7 @@ class WebhookRunner {
 
     this.config = _.merge(defaultConfiguration, configuration);
 
-    this.queue = new WorkerQueue({ logger, concurency: 5 });
+    this.queue = new WorkerQueue({ logger, concurrency: 5 });
     this.queue.subscribe(this.executeListener.bind(this));
   }
 

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

@@ -0,0 +1,74 @@
+import { GetAttributeValue } from './utils';
+
+/**
+ * List of all the Strapi attribute types
+ */
+export type AttributeType =
+  | 'string'
+  | 'text'
+  | 'richtext'
+  | 'email'
+  | 'password'
+  | 'date'
+  | 'time'
+  | 'datetime'
+  | 'timestamp'
+  | 'integer'
+  | 'biginteger'
+  | 'float'
+  | 'decimal'
+  | 'uid'
+  | 'enumeration'
+  | 'boolean'
+  | 'json'
+  | 'media'
+  | 'relation'
+  | 'component'
+  | 'dynamiczone';
+
+/**
+ * Most basic shape of a schema attribute
+ */
+export interface Attribute<T extends AttributeType = AttributeType> {
+  /**
+   * Type of the attribute
+   */
+  type: T;
+
+  /**
+   * Options defined and used by the plugins
+   */
+  pluginOptions?: object;
+}
+
+// Common attributes Options
+
+export interface RequiredOption {
+  required?: boolean;
+}
+
+export interface PrivateOption {
+  private?: boolean;
+}
+
+export interface UniqueOption {
+  unique?: boolean;
+}
+
+export interface DefaultOption<T> {
+  default?: T;
+}
+
+export interface ConfigurableOption {
+  configurable?: boolean;
+}
+
+export interface MinMaxOption<T = number> {
+  min?: T;
+  max?: T;
+}
+
+export interface MinMaxLengthOption {
+  minLength?: number;
+  maxLength?: number;
+}

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

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

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

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

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

@@ -0,0 +1,42 @@
+/**
+ * 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;
+
+/**
+ * Setters for the attributes options
+ */
+
+// required
+export type RequiredAttribute = { required: true };
+export type NonRequiredAttribute = { required: false };
+
+// private
+export type PrivateAttribute = { private: true };
+export type NonPrivateAttribute = { private: false };
+
+// unique
+export type UniqueAttribute = { unique: true };
+export type NonUniqueAttribute = { unique: false };
+
+// configurable
+export type ConfigurableAttribute = { configurable: true };
+export type NonConfigurableAttribute = { configurable: false };
+
+// min/max
+export type SetMinMax<T extends MinMaxOption<U>, U = number> = T;
+
+// minLength/maxLength
+export type SetMinMaxLength<T extends MinMaxLengthOption> = T;
+
+// pluginOptions
+export type SetPluginOptions<T extends object = object> = { pluginOptions?: T };
+
+// default
+export type DefaultTo<T> = { default: T };

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

@@ -0,0 +1,41 @@
+import { Attribute, ConfigurableOption, MinMaxOption, PrivateOption, RequiredOption } from './base';
+import { GetAttributesValues } from './utils';
+
+export interface ComponentAttributeProperties<
+  // Targeted component
+  T extends Strapi.ComponentUIDs,
+  // Repeatable
+  R extends boolean = false
+> {
+  component: T;
+  repeatable?: R;
+}
+
+export type ComponentAttribute<
+  // Targeted component
+  T extends Strapi.ComponentUIDs,
+  // Repeatable
+  R extends boolean = false
+> = Attribute<'component'> &
+  // Component Properties
+  ComponentAttributeProperties<T, R> &
+  // Options
+  ConfigurableOption &
+  MinMaxOption &
+  PrivateOption &
+  RequiredOption;
+
+export type ComponentValue<T extends Strapi.ComponentUIDs, R extends boolean> = GetAttributesValues<
+  T
+> extends infer V
+  ? R extends true
+    ? V[]
+    : V
+  : never;
+
+export type GetComponentAttributeValue<T extends Attribute> = T extends ComponentAttribute<
+  infer U,
+  infer R
+>
+  ? ComponentValue<U, R>
+  : never;

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

@@ -0,0 +1,22 @@
+import {
+  Attribute,
+  ConfigurableOption,
+  DefaultOption,
+  PrivateOption,
+  RequiredOption,
+  UniqueOption,
+} from './base';
+
+export type DateTimeAttribute = Attribute<'datetime'> &
+  // Options
+  ConfigurableOption &
+  DefaultOption<DateTimeValue> &
+  PrivateOption &
+  RequiredOption &
+  UniqueOption;
+
+export type DateTimeValue = string;
+
+export type GetDateTimeAttributeValue<T extends Attribute> = T extends DateTimeAttribute
+  ? DateTimeValue
+  : never;

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

@@ -0,0 +1,22 @@
+import {
+  Attribute,
+  ConfigurableOption,
+  DefaultOption,
+  PrivateOption,
+  RequiredOption,
+  UniqueOption,
+} from './base';
+
+export type DateAttribute = Attribute<'date'> &
+  // Options
+  ConfigurableOption &
+  DefaultOption<DateValue> &
+  PrivateOption &
+  RequiredOption &
+  UniqueOption;
+
+export type DateValue = Date;
+
+export type GetDateAttributeValue<T extends Attribute> = T extends DateAttribute
+  ? DateValue
+  : never;

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

@@ -0,0 +1,22 @@
+import {
+  Attribute,
+  ConfigurableOption,
+  DefaultOption,
+  MinMaxOption,
+  PrivateOption,
+  RequiredOption,
+} from './base';
+
+export type DecimalAttribute = Attribute<'decimal'> &
+  // Options
+  ConfigurableOption &
+  DefaultOption<DecimalValue> &
+  MinMaxOption &
+  PrivateOption &
+  RequiredOption;
+
+export type DecimalValue = number;
+
+export type GetDecimalAttributeValue<T extends Attribute> = T extends DecimalAttribute
+  ? DecimalValue
+  : never;

package/lib/types/core/attributes/dynamic-zone.d.ts

@@ -0,0 +1,29 @@
+import { SchemaUID, GetArrayValues } from '../../utils';
+import { Attribute, ConfigurableOption, MinMaxOption, RequiredOption } from './base';
+import { GetAttributesValues } from './utils';
+
+export interface DynamicZoneAttributeProperties<T extends Strapi.ComponentUIDs[] = []> {
+  components: T;
+}
+
+export type DynamicZoneAttribute<T extends Strapi.ComponentUIDs[] = []> = Attribute<'dynamiczone'> &
+  // Properties
+  DynamicZoneAttributeProperties<T> &
+  // Options
+  ConfigurableOption &
+  MinMaxOption &
+  RequiredOption;
+
+type DynamicZoneValue<T extends Strapi.ComponentUIDs[]> = Array<
+  GetArrayValues<T> extends infer P
+    ? P extends SchemaUID
+      ? GetAttributesValues<P> & { __component: P }
+      : never
+    : never
+>;
+
+export type GetDynamicZoneAttributeValue<T extends Attribute> = T extends DynamicZoneAttribute<
+  infer U
+>
+  ? DynamicZoneValue<U>
+  : never;