@strapi/strapi 4.2.3 → 4.3.0

package/lib/commands/services/list.js

@@ -6,7 +6,8 @@ const chalk = require('chalk');
 const strapi = require('../../index');
 
 module.exports = async function() {
-  const app = await strapi().register();
+  const appContext = await strapi.compile();
+  const app = await strapi(appContext).register();
 
   const list = app.container.get('services').keys();
 

package/lib/commands/start.js

@@ -1,8 +1,24 @@
 'use strict';
-
+const fs = require('fs');
+const tsUtils = require('@strapi/typescript-utils');
 const strapi = require('../index');
 
 /**
  * `$ strapi start`
  */
-module.exports = () => strapi().start();
+module.exports = async () => {
+  const appDir = process.cwd();
+
+  const isTSProject = await tsUtils.isUsingTypeScript(appDir);
+
+  const outDir = await tsUtils.resolveOutDir(appDir);
+  const distDir = isTSProject ? outDir : appDir;
+
+  const buildDirExists = fs.existsSync(outDir);
+  if (isTSProject && !buildDirExists)
+    throw new Error(
+      `${outDir} directory not found. Please run the build command before starting your application`
+    );
+
+  return strapi({ appDir, distDir }).start();
+};

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/commands/watchAdmin.js

@@ -3,16 +3,15 @@
 const strapiAdmin = require('@strapi/admin');
 const { getConfigUrls, getAbsoluteServerUrl } = require('@strapi/utils');
 
-const ee = require('../utils/ee');
+const getEnabledPlugins = require('../core/loaders/plugins/get-enabled-plugins');
 const addSlash = require('../utils/addSlash');
 const strapi = require('../index');
-const getEnabledPlugins = require('../core/loaders/plugins/get-enabled-plugins');
 
 module.exports = async function({ browser }) {
-  const dir = process.cwd();
+  const appContext = await strapi.compile();
 
   const strapiInstance = strapi({
-    dir,
+    ...appContext,
     autoReload: true,
     serveAdminPanel: false,
   });
@@ -23,14 +22,12 @@ module.exports = async function({ browser }) {
 
   const adminPort = strapiInstance.config.get('admin.port', 8000);
   const adminHost = strapiInstance.config.get('admin.host', 'localhost');
-  const adminWatchIgnoreFiles = strapiInstance.config.get('admin.watchIgnoreFiles', []);
 
   const backendURL = getAbsoluteServerUrl(strapiInstance.config, true);
 
-  ee({ dir });
-
   strapiAdmin.watchAdmin({
-    dir,
+    appDir: appContext.appDir,
+    buildDestDir: appContext.distDir,
     plugins,
     port: adminPort,
     host: adminHost,
@@ -38,8 +35,6 @@ module.exports = async function({ browser }) {
     options: {
       backend: backendURL,
       adminPath: addSlash(adminPath),
-      watchIgnoreFiles: adminWatchIgnoreFiles,
-      features: ee.isEE ? ee.features.getEnabled() : [],
     },
   });
 };

package/lib/compile.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const tsUtils = require('@strapi/typescript-utils');
+
+module.exports = async dir => {
+  const appDir = dir || process.cwd();
+  const isTSProject = await tsUtils.isUsingTypeScript(appDir);
+  const outDir = await tsUtils.resolveOutDir(appDir);
+
+  if (isTSProject) {
+    await tsUtils.compile(appDir, {
+      watch: false,
+      configOptions: { options: { incremental: true } },
+    });
+  }
+
+  const distDir = isTSProject ? outDir : appDir;
+
+  return { appDir, distDir };
+};

package/lib/core/app-configuration/index.js

@@ -31,12 +31,13 @@ const defaultConfig = {
   },
 };
 
-module.exports = (dir, initialConfig = {}) => {
+module.exports = (dirs, initialConfig = {}) => {
+  const { appDir, distDir } = dirs;
   const { autoReload = false, serveAdminPanel = true } = initialConfig;
 
-  const pkgJSON = require(path.resolve(dir, 'package.json'));
+  const pkgJSON = require(path.resolve(appDir, 'package.json'));
 
-  const configDir = path.resolve(dir || process.cwd(), 'config');
+  const configDir = path.resolve(distDir || process.cwd(), 'config');
 
   const rootConfig = {
     launchedAt: Date.now(),

package/lib/core/app-configuration/load-config-file.js

@@ -4,9 +4,11 @@ const path = require('path');
 const fs = require('fs');
 const { templateConfiguration, env } = require('@strapi/utils');
 
+const importDefault = require('../../utils/import-default');
+
 const loadJsFile = file => {
   try {
-    const jsModule = require(file);
+    const jsModule = importDefault(file);
 
     // call if function
     if (typeof jsModule === 'function') {

package/lib/core/bootstrap.js

@@ -25,9 +25,9 @@ module.exports = async function({ strapi }) {
   }
 
   // ensure public repository exists
-  if (!(await fse.pathExists(strapi.dirs.public))) {
+  if (!(await fse.pathExists(strapi.dirs.static.public))) {
     throw new Error(
-      `The public folder (${strapi.dirs.public}) doesn't exist or is not accessible. Please make sure it exists.`
+      `The public folder (${strapi.dirs.static.public}) doesn't exist or is not accessible. Please make sure it exists.`
     );
   }
 };

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/core/loaders/apis.js

@@ -5,6 +5,7 @@ const { existsSync } = require('fs-extra');
 const _ = require('lodash');
 const fse = require('fs-extra');
 const { isKebabCase } = require('@strapi/utils');
+const { importDefault } = require('../../utils');
 
 const DEFAULT_CONTENT_TYPE = {
   schema: {},
@@ -19,11 +20,11 @@ const isDirectory = fd => fd.isDirectory();
 const isDotFile = fd => fd.name.startsWith('.');
 
 module.exports = async strapi => {
-  if (!existsSync(strapi.dirs.api)) {
-    throw new Error('Missing api folder. Please create one at `./src/api`');
+  if (!existsSync(strapi.dirs.dist.api)) {
+    return;
   }
 
-  const apisFDs = await (await fse.readdir(strapi.dirs.api, { withFileTypes: true }))
+  const apisFDs = await (await fse.readdir(strapi.dirs.dist.api, { withFileTypes: true }))
     .filter(isDirectory)
     .filter(_.negate(isDotFile));
 
@@ -32,7 +33,7 @@ module.exports = async strapi => {
   // only load folders
   for (const apiFD of apisFDs) {
     const apiName = normalizeName(apiFD.name);
-    const api = await loadAPI(join(strapi.dirs.api, apiFD.name));
+    const api = await loadAPI(join(strapi.dirs.dist.api, apiFD.name));
 
     apis[apiName] = api;
   }
@@ -154,7 +155,7 @@ const loadFile = file => {
 
   switch (ext) {
     case '.js':
-      return require(file);
+      return importDefault(file);
     case '.json':
       return fse.readJSON(file);
     default:

package/lib/core/loaders/components.js

@@ -6,19 +6,20 @@ const { pathExists } = require('fs-extra');
 const loadFiles = require('../../load/load-files');
 
 module.exports = async strapi => {
-  if (!(await pathExists(strapi.dirs.components))) {
+  if (!(await pathExists(strapi.dirs.dist.components))) {
     return {};
   }
 
-  const map = await loadFiles(strapi.dirs.components, '*/*.*(js|json)');
+  const map = await loadFiles(strapi.dirs.dist.components, '*/*.*(js|json)');
 
   return Object.keys(map).reduce((acc, category) => {
     Object.keys(map[category]).forEach(key => {
       const schema = map[category][key];
 
-      const filePath = join(strapi.dirs.components, category, schema.__filename__);
-
       if (!schema.collectionName) {
+        // NOTE: We're using the filepath from the app directory instead of the dist for information purpose
+        const filePath = join(strapi.dirs.app.components, category, schema.__filename__);
+
         return strapi.stopWithError(
           `Component ${key} is missing a "collectionName" property.\nVerify file ${filePath}.`
         );

package/lib/core/loaders/middlewares.js

@@ -3,6 +3,8 @@
 const { join, extname, basename } = require('path');
 const fse = require('fs-extra');
 
+const { importDefault } = require('../../utils');
+
 // TODO:: allow folders with index.js inside for bigger policies
 module.exports = async function loadMiddlewares(strapi) {
   const localMiddlewares = await loadLocalMiddlewares(strapi);
@@ -13,7 +15,7 @@ module.exports = async function loadMiddlewares(strapi) {
 };
 
 const loadLocalMiddlewares = async strapi => {
-  const dir = strapi.dirs.middlewares;
+  const dir = strapi.dirs.dist.middlewares;
 
   if (!(await fse.pathExists(dir))) {
     return {};
@@ -28,7 +30,7 @@ const loadLocalMiddlewares = async strapi => {
 
     if (fd.isFile() && extname(name) === '.js') {
       const key = basename(name, '.js');
-      middlewares[key] = require(fullPath);
+      middlewares[key] = importDefault(fullPath);
     }
   }
 

package/lib/core/loaders/plugins/get-enabled-plugins.js

@@ -29,10 +29,11 @@ const toDetailedDeclaration = declaration => {
   let detailedDeclaration = pick(['enabled'], declaration);
   if (has('resolve', declaration)) {
     let pathToPlugin = '';
+
     try {
       pathToPlugin = dirname(require.resolve(declaration.resolve));
     } catch (e) {
-      pathToPlugin = resolve(strapi.dirs.root, declaration.resolve);
+      pathToPlugin = resolve(strapi.dirs.app.root, declaration.resolve);
 
       if (!existsSync(pathToPlugin) || !statSync(pathToPlugin).isDirectory()) {
         throw new Error(`${declaration.resolve} couldn't be resolved`);

package/lib/core/loaders/plugins/get-user-plugins-config.js

@@ -12,9 +12,9 @@ const loadConfigFile = require('../../app-configuration/load-config-file');
  * @return {Promise<{}>}
  */
 const getUserPluginsConfig = async () => {
-  const globalUserConfigPath = join(strapi.dirs.config, 'plugins.js');
+  const globalUserConfigPath = join(strapi.dirs.dist.config, 'plugins.js');
   const currentEnvUserConfigPath = join(
-    strapi.dirs.config,
+    strapi.dirs.dist.config,
     'env',
     process.env.NODE_ENV,
     'plugins.js'

package/lib/core/loaders/plugins/index.js

@@ -26,7 +26,7 @@ const defaultPlugin = {
 };
 
 const applyUserExtension = async plugins => {
-  const extensionsDir = strapi.dirs.extensions;
+  const extensionsDir = strapi.dirs.dist.extensions;
   if (!(await fse.pathExists(extensionsDir))) {
     return;
   }

package/lib/core/loaders/policies.js

@@ -3,9 +3,11 @@
 const { join, extname, basename } = require('path');
 const fse = require('fs-extra');
 
+const { importDefault } = require('../../utils');
+
 // TODO:: allow folders with index.js inside for bigger policies
 module.exports = async function loadPolicies(strapi) {
-  const dir = strapi.dirs.policies;
+  const dir = strapi.dirs.dist.policies;
 
   if (!(await fse.pathExists(dir))) {
     return;
@@ -20,7 +22,7 @@ module.exports = async function loadPolicies(strapi) {
 
     if (fd.isFile() && extname(name) === '.js') {
       const key = basename(name, '.js');
-      policies[key] = require(fullPath);
+      policies[key] = importDefault(fullPath);
     }
   }
 

package/lib/core/loaders/src-index.js

@@ -4,6 +4,8 @@ const { resolve } = require('path');
 const { statSync, existsSync } = require('fs');
 const { yup } = require('@strapi/utils');
 
+const { importDefault } = require('../../utils');
+
 const srcSchema = yup
   .object()
   .shape({
@@ -18,16 +20,16 @@ const validateSrcIndex = srcIndex => {
 };
 
 module.exports = strapi => {
-  if (!existsSync(strapi.dirs.src)) {
-    throw new Error('Missing src folder. Please create one at `./src`');
+  if (!existsSync(strapi.dirs.dist.src)) {
+    return;
   }
 
-  const pathToSrcIndex = resolve(strapi.dirs.src, 'index.js');
+  const pathToSrcIndex = resolve(strapi.dirs.dist.src, 'index.js');
   if (!existsSync(pathToSrcIndex) || statSync(pathToSrcIndex).isDirectory()) {
     return {};
   }
 
-  const srcIndex = require(pathToSrcIndex);
+  const srcIndex = importDefault(pathToSrcIndex);
 
   try {
     validateSrcIndex(srcIndex);

package/lib/core/registries/policies.d.ts

@@ -6,4 +6,4 @@ interface PolicyContext extends BaseContext {
   is(name): boolean;
 }
 
-export type Policy = (ctx: PolicyContext, { strapi: Strapi }) => boolean | undefined;
+export type Policy<T=unknown> = (ctx: PolicyContext,cfg:T, { strapi: Strapi }) => boolean | undefined;

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

@@ -1,25 +1,27 @@
-import { Context } from 'koa';
+import { Context, Next } from 'koa';
 
-type Response = object;
+type ControllerResponse<T = unknown> = T | Promise<T> | undefined;
 
-interface BaseController {
+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 BaseController {
-  find(ctx: Context): Promise<Response>;
-  update(ctx: Context): Promise<Response>;
-  delete(ctx: Context): Promise<Response>;
+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 BaseController {
-  find(ctx: Context): Promise<Response>;
-  findOne(ctx: Context): Promise<Response>;
-  create(ctx: Context): Promise<Response>;
-  update(ctx: Context): Promise<Response>;
-  delete(ctx: Context): Promise<Response>;
+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 Controller = SingleTypeController | CollectionTypeController;
+export type GenericController = Partial<Controller> & {
+  [method: string | number | symbol]: (ctx: Context) => unknown;
+};

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

@@ -1,21 +1,22 @@
 type Entity = object;
 
 interface BaseService {
-  getFetchParams(params: object): object;
+  getFetchParams?(params: object): object;
 }
 
 export interface SingleTypeService extends BaseService {
-  find(params: object): Promise<Entity>;
-  createOrUpdate(params: object): Promise<Entity>;
-  delete(params: object): Promise<Entity>;
+  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[]>;
-  findOne(params: object): Promise<Entity>;
-  create(params: object): Promise<Entity>;
-  update(params: object): Promise<Entity>;
-  delete(params: object): Promise<Entity>;
+  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;
+

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,27 +1,5 @@
-import { Database } from '@strapi/database';
-import { EntityService } from './services/entity-service';
-import { Strapi as StrapiClass } from './Strapi';
+import './global';
 
-export * as factories from './factories';
-interface StrapiInterface extends StrapiClass {
-  query: Database['query'];
-  entityService: EntityService;
-}
-
-export type Strapi = StrapiInterface;
-
-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/index.js

@@ -3,5 +3,6 @@
 const Strapi = require('./Strapi');
 
 Strapi.factories = require('./factories');
+Strapi.compile = require('./compile');
 
 module.exports = Strapi;

package/lib/load/load-files.js

@@ -3,6 +3,8 @@
 const path = require('path');
 const _ = require('lodash');
 const fse = require('fs-extra');
+
+const { importDefault } = require('../utils');
 const glob = require('./glob');
 const filePathToPath = require('./filepath-to-prop-path');
 
@@ -19,7 +21,7 @@ const filePathToPath = require('./filepath-to-prop-path');
 const loadFiles = async (
   dir,
   pattern,
-  { requireFn = require, shouldUseFileNameAsKey = () => true, globArgs = {} } = {}
+  { requireFn = importDefault, shouldUseFileNameAsKey = () => true, globArgs = {} } = {}
 ) => {
   const root = {};
   const files = await glob(pattern, { cwd: dir, ...globArgs });

package/lib/middlewares/favicon.js

@@ -15,5 +15,5 @@ const defaults = {
 module.exports = (config, { strapi }) => {
   const { maxAge, path: faviconPath } = defaultsDeep(defaults, config);
 
-  return favicon(resolve(strapi.dirs.root, faviconPath), { maxAge });
+  return favicon(resolve(strapi.dirs.app.root, faviconPath), { maxAge });
 };

package/lib/middlewares/public/index.js

@@ -80,7 +80,7 @@ module.exports = (config, { strapi }) => {
       {
         method: 'GET',
         path: '/(.*)',
-        handler: koaStatic(strapi.dirs.public, {
+        handler: koaStatic(strapi.dirs.static.public, {
           maxage: maxAge,
           defer: true,
         }),