@strapi/strapi 4.13.3 → 4.14.0-alpha.0

package/lib/commands/utils/pkg.js

@@ -0,0 +1,421 @@
+'use strict';
+
+const fs = require('fs/promises');
+const path = require('path');
+const chalk = require('chalk');
+const yup = require('yup');
+
+/**
+ * Utility functions for loading and validating package.json
+ * this includes the specific validation of specific parts of
+ * the package.json.
+ */
+
+/**
+ * The schema for the package.json that we expect,
+ * currently pretty loose.
+ */
+const packageJsonSchema = yup.object({
+  name: yup.string().required(),
+  version: yup.string().required(),
+  type: yup.string().matches(/(commonjs|module)/),
+  license: yup.string(),
+  bin: yup.mixed().oneOf([
+    yup.string(),
+    yup.object({
+      [yup.string()]: yup.string(),
+    }),
+  ]),
+  main: yup.string(),
+  module: yup.string(),
+  source: yup.string(),
+  types: yup.string(),
+  exports: yup.lazy((value) =>
+    yup.object(
+      typeof value === 'object'
+        ? Object.entries(value).reduce((acc, [key, value]) => {
+            if (typeof value === 'object') {
+              acc[key] = yup
+                .object({
+                  types: yup.string(),
+                  source: yup.string(),
+                  import: yup.string(),
+                  require: yup.string(),
+                  default: yup.string(),
+                })
+                .noUnknown(true);
+            } else {
+              acc[key] = yup
+                .string()
+                .matches(/^\.\/.*\.json$/)
+                .required();
+            }
+
+            return acc;
+          }, {})
+        : undefined
+    )
+  ),
+  files: yup.array(yup.string()),
+  scripts: yup.object(),
+  dependencies: yup.object(),
+  devDependencies: yup.object(),
+  peerDependencies: yup.object(),
+  engines: yup.object(),
+});
+
+/**
+ * @typedef {import('yup').Asserts<typeof packageJsonSchema>} PackageJson
+ */
+
+/**
+ * @description being a task to load the package.json starting from the current working directory
+ * using a shallow find for the package.json  and `fs` to read the file. If no package.json is found,
+ * the process will throw with an appropriate error message.
+ *
+ * @type {(args: { cwd: string, logger: import('./logger').Logger }) => Promise<object>}
+ */
+const loadPkg = async ({ cwd, logger }) => {
+  const directory = path.resolve(cwd);
+
+  const pkgPath = path.join(directory, 'package.json');
+
+  const buffer = await fs.readFile(pkgPath).catch((err) => {
+    logger.debug(err);
+    throw new Error('Could not find a package.json in the current directory');
+  });
+
+  const pkg = JSON.parse(buffer.toString());
+
+  logger.debug('Loaded package.json: \n', pkg);
+
+  return pkg;
+};
+
+/**
+ * @description validate the package.json against a standardised schema using `yup`.
+ * If the validation fails, the process will throw with an appropriate error message.
+ *
+ * @type {(args: { pkg: object }) => Promise<PackageJson | null>}
+ */
+const validatePkg = async ({ pkg }) => {
+  try {
+    const validatedPkg = await packageJsonSchema.validate(pkg, {
+      strict: true,
+    });
+
+    return validatedPkg;
+  } catch (err) {
+    if (err instanceof yup.ValidationError) {
+      switch (err.type) {
+        case 'required':
+          throw new Error(
+            `'${err.path}' in 'package.json' is required as type '${chalk.magenta(
+              yup.reach(packageJsonSchema, err.path).type
+            )}'`
+          );
+        case 'matches':
+          throw new Error(
+            `'${err.path}' in 'package.json' must be of type '${chalk.magenta(
+              err.params.regex
+            )}' (recieved the value '${chalk.magenta(err.params.value)}')`
+          );
+        /**
+         * This will only be thrown if there are keys in the export map
+         * that we don't expect so we can therefore make some assumptions
+         */
+        case 'noUnknown':
+          throw new Error(
+            `'${err.path}' in 'package.json' contains the unknown key ${chalk.magenta(
+              err.params.unknown
+            )}, for compatability only the following keys are allowed: ${chalk.magenta(
+              "['types', 'source', 'import', 'require', 'default']"
+            )}`
+          );
+        default:
+          throw new Error(
+            `'${err.path}' in 'package.json' must be of type '${chalk.magenta(
+              err.params.type
+            )}' (recieved '${chalk.magenta(typeof err.params.value)}')`
+          );
+      }
+    }
+
+    throw err;
+  }
+};
+
+/**
+ * @description validate the `exports` property of the package.json against a set of rules.
+ * If the validation fails, the process will throw with an appropriate error message. If
+ * there is no `exports` property we check the standard export-like properties on the root
+ * of the package.json.
+ *
+ * @type {(args: { pkg: object, logger: import('./logger').Logger }) => Promise<PackageJson>}
+ */
+const validateExportsOrdering = async ({ pkg, logger }) => {
+  if (pkg.exports) {
+    const exports = Object.entries(pkg.exports);
+
+    for (const [expPath, exp] of exports) {
+      if (typeof exp === 'string') {
+        // eslint-disable-next-line no-continue
+        continue;
+      }
+
+      const keys = Object.keys(exp);
+
+      if (!assertFirst('types', keys)) {
+        throw new Error(`exports["${expPath}"]: the 'types' property should be the first property`);
+      }
+
+      if (!assertOrder('import', 'require', keys)) {
+        logger.warn(
+          `exports["${expPath}"]: the 'import' property should come before the 'require' property`
+        );
+      }
+
+      if (!assertOrder('module', 'import', keys)) {
+        logger.warn(
+          `exports["${expPath}"]: the 'module' property should come before 'import' property`
+        );
+      }
+
+      if (!assertLast('default', keys)) {
+        throw new Error(
+          `exports["${expPath}"]: the 'default' property should be the last property`
+        );
+      }
+    }
+  } else if (!['main', 'module'].some((key) => Object.prototype.hasOwnProperty.call(pkg, key))) {
+    throw new Error(`'package.json' must contain a 'main' and 'module' property`);
+  }
+
+  return pkg;
+};
+
+/** @internal */
+function assertFirst(key, arr) {
+  const aIdx = arr.indexOf(key);
+
+  // if not found, then we don't care
+  if (aIdx === -1) {
+    return true;
+  }
+
+  return aIdx === 0;
+}
+
+/** @internal */
+function assertLast(key, arr) {
+  const aIdx = arr.indexOf(key);
+
+  // if not found, then we don't care
+  if (aIdx === -1) {
+    return true;
+  }
+
+  return aIdx === arr.length - 1;
+}
+
+/** @internal */
+function assertOrder(keyA, keyB, arr) {
+  const aIdx = arr.indexOf(keyA);
+  const bIdx = arr.indexOf(keyB);
+
+  // if either is not found, then we don't care
+  if (aIdx === -1 || bIdx === -1) {
+    return true;
+  }
+
+  return aIdx < bIdx;
+}
+
+/**
+ * @typedef {Object} Extensions
+ * @property {string} commonjs
+ * @property {string} esm
+ */
+
+/**
+ * @typedef {Object} ExtMap
+ * @property {Extensions} commonjs
+ * @property {Extensions} esm
+ */
+
+/**
+ * @internal
+ *
+ * @type {ExtMap}
+ */
+const DEFAULT_PKG_EXT_MAP = {
+  // pkg.type: "commonjs"
+  commonjs: {
+    cjs: '.js',
+    es: '.mjs',
+  },
+
+  // pkg.type: "module"
+  module: {
+    cjs: '.cjs',
+    es: '.js',
+  },
+};
+
+/**
+ * We potentially might need to support legacy exports or as package
+ * development continues we have space to tweak this.
+ *
+ * @type {() => ExtMap}
+ */
+const getExportExtensionMap = () => {
+  return DEFAULT_PKG_EXT_MAP;
+};
+
+/**
+ * @internal
+ *
+ * @description validate the `require` and `import` properties of a given exports maps from the package.json
+ * returning if any errors are found.
+ *
+ * @type {(_exports: unknown, options: {extMap: ExtMap; pkg: PackageJson}) => string[]}
+ */
+const validateExports = (_exports, options) => {
+  const { extMap, pkg } = options;
+  const ext = extMap[pkg.type || 'commonjs'];
+
+  const errors = [];
+
+  for (const exp of _exports) {
+    if (exp.require && !exp.require.endsWith(ext.cjs)) {
+      errors.push(
+        `package.json with \`type: "${pkg.type}"\` - \`exports["${exp._path}"].require\` must end with "${ext.cjs}"`
+      );
+    }
+
+    if (exp.import && !exp.import.endsWith(ext.es)) {
+      errors.push(
+        `package.json with \`type: "${pkg.type}"\` - \`exports["${exp._path}"].import\` must end with "${ext.es}"`
+      );
+    }
+  }
+
+  return errors;
+};
+
+/**
+ * @typedef {Object} Export
+ * @property {string} _path the path of the export, `.` for the root.
+ * @property {string=} types the path to the types file
+ * @property {string} source the path to the source file
+ * @property {string=} require the path to the commonjs require file
+ * @property {string=} import the path to the esm import file
+ * @property {string=} default the path to the default file
+ */
+
+/**
+ * @description parse the exports map from the package.json into a standardised
+ * format that we can use to generate build tasks from.
+ *
+ * @type {(args: { extMap: ExtMap, pkg: PackageJson }) => Export[]}
+ */
+const parseExports = ({ extMap, pkg }) => {
+  /**
+   * @type {Export}
+   */
+  const rootExport = {
+    _path: '.',
+    types: pkg.types,
+    source: pkg.source,
+    require: pkg.main,
+    import: pkg.module,
+    default: pkg.module || pkg.main,
+  };
+
+  /**
+   * @type {Export[]}
+   */
+  const extraExports = [];
+
+  /**
+   * @type {string[]}
+   */
+  const errors = [];
+
+  if (pkg.exports) {
+    if (!pkg.exports['./package.json']) {
+      errors.push('package.json: `exports["./package.json"] must be declared.');
+    }
+
+    Object.entries(pkg.exports).forEach(([path, entry]) => {
+      if (path.endsWith('.json')) {
+        if (path === './package.json' && entry !== './package.json') {
+          errors.push(`package.json: 'exports["./package.json"]' must be './package.json'.`);
+        }
+      } else if (Boolean(entry) && typeof entry === 'object' && !Array.isArray(entry)) {
+        if (path === '.') {
+          if (entry.require && rootExport.require && entry.require !== rootExport.require) {
+            errors.push(
+              `package.json: mismatch between 'main' and 'exports.require'. These must be equal.`
+            );
+          }
+
+          if (entry.import && rootExport.import && entry.import !== rootExport.import) {
+            errors.push(
+              `package.json: mismatch between 'module' and 'exports.import' These must be equal.`
+            );
+          }
+
+          if (entry.types && rootExport.types && entry.types !== rootExport.types) {
+            errors.push(
+              `package.json: mismatch between 'types' and 'exports.types'. These must be equal.`
+            );
+          }
+
+          if (entry.source && rootExport.source && entry.source !== rootExport.source) {
+            errors.push(
+              `package.json: mismatch between 'source' and 'exports.source'. These must be equal.`
+            );
+          }
+
+          Object.assign(rootExport, entry);
+        } else {
+          const extraExport = {
+            _exported: true,
+            _path: path,
+            ...entry,
+          };
+
+          extraExports.push(extraExport);
+        }
+      } else {
+        errors.push('package.json: exports must be an object');
+      }
+    });
+  }
+
+  const _exports = [
+    /**
+     * In the case of strapi plugins, we don't have a root export because we
+     * ship a server side and client side package. So this can be completely omitted.
+     */
+    Object.values(rootExport).some((exp) => exp !== rootExport._path && Boolean(exp)) && rootExport,
+    ...extraExports,
+  ].filter(Boolean);
+
+  errors.push(...validateExports(_exports, { extMap, pkg }));
+
+  if (errors.length) {
+    throw new Error(`\n- ${errors.join('\n- ')}`);
+  }
+
+  return _exports;
+};
+
+module.exports = {
+  loadPkg,
+  validatePkg,
+  validateExportsOrdering,
+  getExportExtensionMap,
+  parseExports,
+};

package/lib/services/entity-service/types/params/filters/index.d.ts

@@ -2,12 +2,9 @@ import type { Attribute, Common, Utils } from '@strapi/strapi';
 
 import type * as Operator from './operators';
 import type * as AttributeUtils from '../attributes';
-import type Params from '../index';
 
 export { Operator };
 
-type IDKey = 'id';
-
 /**
  * Filter representation for nested attributes
  */
@@ -23,17 +20,11 @@ type NestedAttributeCondition<
  */
 type AttributeCondition<
   TSchemaUID extends Common.UID.Schema,
-  TAttributeName extends IDKey | Attribute.GetKeys<TSchemaUID>
-> = Utils.Expression.MatchFirst<
-  [
-    // Special catch for manually added ID attributes
-    [Utils.Expression.StrictEqual<TAttributeName, IDKey>, Params.Attribute.ID],
-    [
-      Utils.Expression.IsNotNever<TAttributeName>,
-      // Get the filter attribute value for the given attribute
-      AttributeUtils.GetValue<Attribute.Get<TSchemaUID, Exclude<TAttributeName, IDKey>>>
-    ]
-  ],
+  TAttributeName extends Attribute.GetKeys<TSchemaUID>
+> = Utils.Expression.If<
+  Utils.Expression.IsNotNever<TAttributeName>,
+  // Get the filter attribute value for the given attribute
+  AttributeUtils.GetValue<Attribute.Get<TSchemaUID, TAttributeName>>,
   // Fallback to the list of all possible scalar attributes' value if the attribute is not valid (never)
   AttributeUtils.ScalarValues
 > extends infer TAttributeValue
@@ -73,17 +64,11 @@ export type ObjectNotation<TSchemaUID extends Common.UID.Schema> = {
           Utils.Expression.IsNotNever<TNestedKeys>
         >,
         // Strongly typed representation of the filter object tree
-        {
-          [TIter in IDKey | TScalarKeys]?: AttributeCondition<TSchemaUID, TIter>;
-        } & {
-          [TIter in TNestedKeys]?: NestedAttributeCondition<TSchemaUID, TIter>;
-        },
+        | { [TIter in TScalarKeys]?: AttributeCondition<TSchemaUID, TIter> }
+        | { [TIter in TNestedKeys]?: NestedAttributeCondition<TSchemaUID, TIter> },
         // Generic representation of the filter object tree in case we don't have access to the attributes' list
-        {
-          [TKey in string]?:
-            | AttributeCondition<TSchemaUID, never>
-            | NestedAttributeCondition<TSchemaUID, never>;
-        }
+        | { [TKey in string]?: AttributeCondition<TSchemaUID, never> }
+        | { [TKey in string]?: NestedAttributeCondition<TSchemaUID, never> }
       >
     : never);
 

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

@@ -8,7 +8,7 @@ export type Timestamp = Attribute.OfType<'timestamp'> &
   Attribute.RequiredOption &
   Attribute.UniqueOption;
 
-export type TimestampValue = globalThis.Date | number | string;
+export type TimestampValue = globalThis.Date | number | string;
 
 export type GetTimestampValue<T extends Attribute.Attribute> = T extends Timestamp
   ? TimestampValue

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

@@ -11,7 +11,7 @@ interface CustomFieldServerOptions {
   /**
    * The name of the plugin creating the custom field
    */
-  plugin?: string;
+  pluginId?: string;
 
   /**
    * The existing Strapi data type the custom field uses

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/strapi",
-  "version": "4.13.3",
+  "version": "4.14.0-alpha.0",
   "description": "An open source headless CMS solution to create and manage your own API. It provides a powerful dashboard and features to make your life easier. Databases supported: MySQL, MariaDB, PostgreSQL, SQLite",
   "keywords": [
     "strapi",
@@ -81,21 +81,23 @@
   "dependencies": {
     "@koa/cors": "3.4.3",
     "@koa/router": "10.1.1",
-    "@strapi/admin": "4.13.3",
-    "@strapi/data-transfer": "4.13.3",
-    "@strapi/database": "4.13.3",
-    "@strapi/generate-new": "4.13.3",
-    "@strapi/generators": "4.13.3",
-    "@strapi/logger": "4.13.3",
-    "@strapi/permissions": "4.13.3",
-    "@strapi/plugin-content-manager": "4.13.3",
-    "@strapi/plugin-content-type-builder": "4.13.3",
-    "@strapi/plugin-email": "4.13.3",
-    "@strapi/plugin-upload": "4.13.3",
-    "@strapi/typescript-utils": "4.13.3",
-    "@strapi/utils": "4.13.3",
+    "@strapi/admin": "4.14.0-alpha.0",
+    "@strapi/data-transfer": "4.14.0-alpha.0",
+    "@strapi/database": "4.14.0-alpha.0",
+    "@strapi/generate-new": "4.14.0-alpha.0",
+    "@strapi/generators": "4.14.0-alpha.0",
+    "@strapi/logger": "4.14.0-alpha.0",
+    "@strapi/permissions": "4.14.0-alpha.0",
+    "@strapi/plugin-content-manager": "4.14.0-alpha.0",
+    "@strapi/plugin-content-type-builder": "4.14.0-alpha.0",
+    "@strapi/plugin-email": "4.14.0-alpha.0",
+    "@strapi/plugin-upload": "4.14.0-alpha.0",
+    "@strapi/typescript-utils": "4.14.0-alpha.0",
+    "@strapi/utils": "4.14.0-alpha.0",
+    "@vitejs/plugin-react": "4.0.4",
     "bcryptjs": "2.4.3",
     "boxen": "5.1.2",
+    "browserslist-to-esbuild": "1.2.0",
     "chalk": "4.1.2",
     "chokidar": "3.5.3",
     "ci-info": "3.8.0",
@@ -132,7 +134,10 @@
     "qs": "6.11.1",
     "resolve-cwd": "3.0.0",
     "semver": "7.5.4",
-    "statuses": "2.0.1"
+    "statuses": "2.0.1",
+    "typescript": "5.1.3",
+    "vite": "4.4.9",
+    "yup": "0.32.9"
   },
   "devDependencies": {
     "supertest": "6.3.3",
@@ -143,5 +148,5 @@
     "node": ">=16.0.0 <=20.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "377efaba51b6499e85f7768049a3246ccb9be57c"
+  "gitHead": "1c3c286e2481cd8cbbb50e0e0bb8fbd0b824d2e4"
 }