@strapi/strapi 4.3.0-beta.1 → 4.3.0-beta.2

package/bin/strapi.js

@@ -213,6 +213,17 @@ program
   .description('List all the application content-types')
   .action(getLocalScript('content-types/list'));
 
+program
+  .command('content-types:generate-types')
+  .description('Generate TypeScript typings for the content-types')
+  .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)
+  .action(getLocalScript('content-types/generate-types'));
+
 program
   .command('hooks:list')
   .description('List all the application hooks')
@@ -231,7 +242,13 @@ 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.parseAsync(process.argv);

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

@@ -0,0 +1,20 @@
+'use strict';
+
+const tsUtils = require('@strapi/typescript-utils');
+
+const strapi = require('../../index');
+
+module.exports = async function({ outDir, file, verbose }) {
+  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,
+  });
+
+  app.destroy();
+};

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/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/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/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;

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

@@ -0,0 +1,24 @@
+import {
+  Attribute,
+  ConfigurableOption,
+  DefaultOption,
+  MinMaxLengthOption,
+  PrivateOption,
+  RequiredOption,
+  UniqueOption,
+} from './base';
+
+export type EmailAttribute = Attribute<'email'> &
+  // Options
+  ConfigurableOption &
+  DefaultOption<EmailValue> &
+  MinMaxLengthOption &
+  PrivateOption &
+  RequiredOption &
+  UniqueOption;
+
+export type EmailValue = string;
+
+export type GetEmailAttributeValue<T extends Attribute> = T extends EmailAttribute
+  ? EmailValue
+  : never;

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

@@ -0,0 +1,28 @@
+import { GetArrayValues } from '../../utils';
+import {
+  Attribute,
+  ConfigurableOption,
+  DefaultOption,
+  PrivateOption,
+  RequiredOption,
+} from './base';
+
+export interface EnumerationAttributeProperties<T extends string[] = []> {
+  enum: T;
+}
+
+export type EnumerationAttribute<T extends string[] = []> = Attribute<'enumeration'> &
+  EnumerationAttributeProperties<T> &
+  // Options
+  ConfigurableOption &
+  DefaultOption<T> &
+  PrivateOption &
+  RequiredOption;
+
+export type EnumerationValue<T extends string[]> = GetArrayValues<T>;
+
+export type GetEnumerationAttributeValue<T extends Attribute> = T extends EnumerationAttribute<
+  infer U
+>
+  ? EnumerationValue<U>
+  : never;

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

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

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

@@ -0,0 +1,26 @@
+export * from './base';
+
+export * from './biginteger';
+export * from './boolean';
+export * from './component';
+export * from './decimal';
+export * from './dynamic-zone';
+export * from './enumeration';
+export * from './float';
+export * from './integer';
+export * from './json';
+export * from './media';
+export * from './password';
+export * from './relation';
+export * from './richtext';
+export * from './string';
+export * from './text';
+export * from './uid';
+export * from './email';
+export * from './date';
+export * from './date-time';
+export * from './timestamp';
+export * from './time';
+
+export * from './common';
+export * from './utils';