@strapi/strapi 4.14.0-beta.0 → 4.15.0-alpha.0

package/lib/core/registries/custom-fields.js

@@ -1,89 +0,0 @@
-'use strict';
-
-const { has, isPlainObject } = require('lodash/fp');
-
-const ALLOWED_TYPES = [
-  'biginteger',
-  'boolean',
-  'date',
-  'datetime',
-  'decimal',
-  'email',
-  'enumeration',
-  'float',
-  'integer',
-  'json',
-  'password',
-  'richtext',
-  'string',
-  'text',
-  'time',
-  'uid',
-];
-
-const customFieldsRegistry = (strapi) => {
-  const customFields = {};
-
-  return {
-    getAll() {
-      return customFields;
-    },
-    get(customField) {
-      const registeredCustomField = customFields[customField];
-      if (!registeredCustomField) {
-        throw new Error(`Could not find Custom Field: ${customField}`);
-      }
-
-      return registeredCustomField;
-    },
-    add(customField) {
-      const customFieldList = Array.isArray(customField) ? customField : [customField];
-
-      for (const cf of customFieldList) {
-        if (!has('name', cf) || !has('type', cf)) {
-          throw new Error(`Custom fields require a 'name' and 'type' key`);
-        }
-
-        const { name, plugin, type, inputSize } = cf;
-        if (!ALLOWED_TYPES.includes(type)) {
-          throw new Error(
-            `Custom field type: '${type}' is not a valid Strapi type or it can't be used with a Custom Field`
-          );
-        }
-
-        const isValidObjectKey = /^(?![0-9])[a-zA-Z0-9$_-]+$/g;
-        if (!isValidObjectKey.test(name)) {
-          throw new Error(`Custom field name: '${name}' is not a valid object key`);
-        }
-
-        // Validate inputSize when provided
-        if (inputSize) {
-          if (
-            !isPlainObject(inputSize) ||
-            !has('default', inputSize) ||
-            !has('isResizable', inputSize)
-          ) {
-            throw new Error(`inputSize should be an object with 'default' and 'isResizable' keys`);
-          }
-          if (![4, 6, 8, 12].includes(inputSize.default)) {
-            throw new Error('Custom fields require a valid default input size');
-          }
-          if (typeof inputSize.isResizable !== 'boolean') {
-            throw new Error('Custom fields should specify if their input is resizable');
-          }
-        }
-
-        // When no plugin is specified, or it isn't found in Strapi, default to global
-        const uid = strapi.plugin(plugin) ? `plugin::${plugin}.${name}` : `global::${name}`;
-
-        if (has(uid, customFields)) {
-          throw new Error(`Custom field: '${uid}' has already been registered`);
-        }
-
-        customFields[uid] = cf;
-      }
-    },
-  };
-};
-
-module.exports = customFieldsRegistry;

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

@@ -1,17 +0,0 @@
-type Handler = (context: any) => any;
-
-type AsyncHook = {
-  handlers: Handler[];
-  register(handler: Handler): this;
-  delete(handler: Handler): this;
-  call(): Promise<void>;
-};
-
-type SyncHook = {
-  get handlers(): Handler[];
-  register(handler: Handler): this;
-  delete(handler: Handler): this;
-  call(): void;
-};
-
-export type Hook = AsyncHook | SyncHook;

package/lib/core/registries/hooks.js

@@ -1,87 +0,0 @@
-'use strict';
-
-const { pickBy } = require('lodash/fp');
-const { addNamespace, hasNamespace } = require('../utils');
-
-/**
- * @typedef {import('./hooks').Hook} Hook
- */
-
-const hooksRegistry = () => {
-  const hooks = {};
-
-  return {
-    /**
-     * Returns this list of registered hooks uids
-     * @returns {string[]}
-     */
-    keys() {
-      return Object.keys(hooks);
-    },
-
-    /**
-     * Returns the instance of a hook.
-     * @param {string} uid
-     * @returns {Hook}
-     */
-    get(uid) {
-      return hooks[uid];
-    },
-
-    /**
-     * Returns a map with all the hooks in a namespace
-     * @param {string} namespace
-     * @returns {{ [key: string]: Hook }}
-     */
-    getAll(namespace) {
-      return pickBy((_, uid) => hasNamespace(uid, namespace))(hooks);
-    },
-
-    /**
-     * Registers a hook
-     * @param {string} uid
-     * @param {Hook} hook
-     */
-    set(uid, hook) {
-      hooks[uid] = hook;
-      return this;
-    },
-
-    /**
-     * Registers a map of hooks for a specific namespace
-     * @param {string} namespace
-     * @param {{ [key: string]: Hook }} newHooks
-     * @returns
-     */
-    add(namespace, hooks) {
-      for (const hookName of Object.keys(hooks)) {
-        const hook = hooks[hookName];
-        const uid = addNamespace(hookName, namespace);
-
-        this.set(uid, hook);
-      }
-
-      return this;
-    },
-
-    /**
-     * Wraps a hook to extend it
-     * @param {string} uid
-     * @param {(hook: Hook) => Hook} extendFn
-     */
-    extend(uid, extendFn) {
-      const currentHook = this.get(uid);
-
-      if (!currentHook) {
-        throw new Error(`Hook ${uid} doesn't exist`);
-      }
-
-      const newHook = extendFn(currentHook);
-      hooks[uid] = newHook;
-
-      return this;
-    },
-  };
-};
-
-module.exports = hooksRegistry;

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

@@ -1,5 +0,0 @@
-import { BaseContext, Middleware as KoaMiddleware } from 'koa';
-import { Strapi } from '../../';
-import { MiddlewareFactory } from '../../middlewares';
-
-export type Middleware = KoaMiddleware | MiddlewareFactory;

package/lib/core/registries/middlewares.js

@@ -1,89 +0,0 @@
-'use strict';
-
-const { pickBy, has } = require('lodash/fp');
-const { addNamespace, hasNamespace } = require('../utils');
-
-/**
- * @typedef {import('./middlewares').Middleware} Middleware
- */
-
-// TODO: move instantiation part here instead of in the server service
-const middlewaresRegistry = () => {
-  const middlewares = {};
-
-  return {
-    /**
-     * Returns this list of registered middlewares uids
-     * @returns {string[]}
-     */
-    keys() {
-      return Object.keys(middlewares);
-    },
-
-    /**
-     * Returns the instance of a middleware. Instantiate the middleware if not already done
-     * @param {string} uid
-     * @returns {Middleware}
-     */
-    get(uid) {
-      return middlewares[uid];
-    },
-
-    /**
-     * Returns a map with all the middlewares in a namespace
-     * @param {string} namespace
-     * @returns {{ [key: string]: Middleware }}
-     */
-    getAll(namespace) {
-      return pickBy((_, uid) => hasNamespace(uid, namespace))(middlewares);
-    },
-
-    /**
-     * Registers a middleware
-     * @param {string} uid
-     * @param {Middleware} middleware
-     */
-    set(uid, middleware) {
-      middlewares[uid] = middleware;
-      return this;
-    },
-
-    /**
-     * Registers a map of middlewares for a specific namespace
-     * @param {string} namespace
-     * @param {{ [key: string]: Middleware }} newMiddlewares
-     * @returns
-     */
-    add(namespace, rawMiddlewares = {}) {
-      for (const middlewareName of Object.keys(rawMiddlewares)) {
-        const middleware = rawMiddlewares[middlewareName];
-        const uid = addNamespace(middlewareName, namespace);
-
-        if (has(uid, middlewares)) {
-          throw new Error(`Middleware ${uid} has already been registered.`);
-        }
-        middlewares[uid] = middleware;
-      }
-    },
-
-    /**
-     * Wraps a middleware to extend it
-     * @param {string} uid
-     * @param {(middleware: Middleware) => Middleware} extendFn
-     */
-    extend(uid, extendFn) {
-      const currentMiddleware = this.get(uid);
-
-      if (!currentMiddleware) {
-        throw new Error(`Middleware ${uid} doesn't exist`);
-      }
-
-      const newMiddleware = extendFn(currentMiddleware);
-      middlewares[uid] = newMiddleware;
-
-      return this;
-    },
-  };
-};
-
-module.exports = middlewaresRegistry;

package/lib/core/registries/modules.js

@@ -1,44 +0,0 @@
-'use strict';
-
-const { pickBy, has } = require('lodash/fp');
-const { createModule } = require('../domain/module');
-
-const modulesRegistry = (strapi) => {
-  const modules = {};
-
-  return {
-    get(namespace) {
-      return modules[namespace];
-    },
-    getAll(prefix = '') {
-      return pickBy((mod, namespace) => namespace.startsWith(prefix))(modules);
-    },
-    add(namespace, rawModule) {
-      if (has(namespace, modules)) {
-        throw new Error(`Module ${namespace} has already been registered.`);
-      }
-
-      modules[namespace] = createModule(namespace, rawModule, strapi);
-      modules[namespace].load();
-
-      return modules[namespace];
-    },
-    async bootstrap() {
-      for (const mod of Object.values(modules)) {
-        await mod.bootstrap();
-      }
-    },
-    async register() {
-      for (const mod of Object.values(modules)) {
-        await mod.register();
-      }
-    },
-    async destroy() {
-      for (const mod of Object.values(modules)) {
-        await mod.destroy();
-      }
-    },
-  };
-};
-
-module.exports = modulesRegistry;

package/lib/core/registries/plugins.js

@@ -1,28 +0,0 @@
-'use strict';
-
-const { has } = require('lodash/fp');
-
-const pluginsRegistry = (strapi) => {
-  const plugins = {};
-
-  return {
-    get(name) {
-      return plugins[name];
-    },
-    getAll() {
-      return plugins;
-    },
-    add(name, pluginConfig) {
-      if (has(name, plugins)) {
-        throw new Error(`Plugin ${name} has already been registered.`);
-      }
-
-      const pluginModule = strapi.container.get('modules').add(`plugin::${name}`, pluginConfig);
-      plugins[name] = pluginModule;
-
-      return plugins[name];
-    },
-  };
-};
-
-module.exports = pluginsRegistry;

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

@@ -1,13 +0,0 @@
-import { ExtendableContext } from 'koa';
-import { Strapi } from '../../';
-
-interface PolicyContext extends ExtendableContext {
-  type: string;
-  is(name: string): boolean;
-}
-
-export type Policy<T = unknown> = (
-  ctx: PolicyContext,
-  cfg: T,
-  { strapi: Strapi }
-) => boolean | undefined;

package/lib/core/registries/policies.js

@@ -1,89 +0,0 @@
-'use strict';
-
-const { pickBy, has } = require('lodash/fp');
-const { addNamespace, hasNamespace } = require('../utils');
-
-/**
- * @typedef {import('./policies').Policy} Policy
- */
-
-// TODO: move instantiation part here instead of in the policy utils
-const policiesRegistry = () => {
-  const policies = {};
-
-  return {
-    /**
-     * Returns this list of registered policies uids
-     * @returns {string[]}
-     */
-    keys() {
-      return Object.keys(policies);
-    },
-
-    /**
-     * Returns the instance of a policy. Instantiate the policy if not already done
-     * @param {string} uid
-     * @returns {Policy}
-     */
-    get(uid) {
-      return policies[uid];
-    },
-
-    /**
-     * Returns a map with all the policies in a namespace
-     * @param {string} namespace
-     * @returns {{ [key: string]: Policy }}
-     */
-    getAll(namespace) {
-      return pickBy((_, uid) => hasNamespace(uid, namespace))(policies);
-    },
-
-    /**
-     * Registers a policy
-     * @param {string} uid
-     * @param {Policy} policy
-     */
-    set(uid, policy) {
-      policies[uid] = policy;
-      return this;
-    },
-
-    /**
-     * Registers a map of policies for a specific namespace
-     * @param {string} namespace
-     * @param {{ [key: string]: Policy }} newPolicies
-     * @returns
-     */
-    add(namespace, newPolicies) {
-      for (const policyName of Object.keys(newPolicies)) {
-        const policy = newPolicies[policyName];
-        const uid = addNamespace(policyName, namespace);
-
-        if (has(uid, policies)) {
-          throw new Error(`Policy ${uid} has already been registered.`);
-        }
-        policies[uid] = policy;
-      }
-    },
-
-    /**
-     * Wraps a policy to extend it
-     * @param {string} uid
-     * @param {(policy: Policy) => Policy} extendFn
-     */
-    extend(uid, extendFn) {
-      const currentPolicy = this.get(uid);
-
-      if (!currentPolicy) {
-        throw new Error(`Policy ${uid} doesn't exist`);
-      }
-
-      const newPolicy = extendFn(currentPolicy);
-      policies[uid] = newPolicy;
-
-      return this;
-    },
-  };
-};
-
-module.exports = policiesRegistry;

package/lib/core/registries/sanitizers.js

@@ -1,26 +0,0 @@
-'use strict';
-
-const _ = require('lodash');
-
-const sanitizersRegistry = () => {
-  const sanitizers = {};
-
-  return {
-    get(path) {
-      return _.get(sanitizers, path, []);
-    },
-    add(path, sanitizer) {
-      this.get(path).push(sanitizer);
-      return this;
-    },
-    set(path, value = []) {
-      _.set(sanitizers, path, value);
-      return this;
-    },
-    has(path) {
-      return _.has(sanitizers, path);
-    },
-  };
-};
-
-module.exports = sanitizersRegistry;

package/lib/core/registries/services.js

@@ -1,114 +0,0 @@
-'use strict';
-
-const { pickBy, has } = require('lodash/fp');
-const { addNamespace, hasNamespace } = require('../utils');
-
-/**
- * @typedef {import('./services').Service} Service
- * @typedef {import('./services').ServiceFactory} ServiceFactory
- */
-
-const servicesRegistry = (strapi) => {
-  const services = {};
-  const instantiatedServices = {};
-
-  return {
-    /**
-     * Returns this list of registered services uids
-     * @returns {string[]}
-     */
-    keys() {
-      return Object.keys(services);
-    },
-
-    /**
-     * Returns the instance of a service. Instantiate the service if not already done
-     * @param {string} uid
-     * @returns {Service}
-     */
-    get(uid) {
-      if (instantiatedServices[uid]) {
-        return instantiatedServices[uid];
-      }
-
-      const service = services[uid];
-      if (service) {
-        instantiatedServices[uid] = typeof service === 'function' ? service({ strapi }) : service;
-        return instantiatedServices[uid];
-      }
-    },
-
-    /**
-     * Returns a map with all the services in a namespace
-     * @param {string} namespace
-     * @returns {{ [key: string]: Service }}
-     */
-    getAll(namespace) {
-      const filteredServices = pickBy((_, uid) => hasNamespace(uid, namespace))(services);
-
-      // create lazy accessor to avoid instantiating the services;
-      const map = {};
-      for (const uid of Object.keys(filteredServices)) {
-        Object.defineProperty(map, uid, {
-          enumerable: true,
-          get: () => {
-            return this.get(uid);
-          },
-        });
-      }
-
-      return map;
-    },
-
-    /**
-     * Registers a service
-     * @param {string} uid
-     * @param {Service} service
-     */
-    set(uid, service) {
-      services[uid] = service;
-      delete instantiatedServices[uid];
-      return this;
-    },
-
-    /**
-     * Registers a map of services for a specific namespace
-     * @param {string} namespace
-     * @param {{ [key: string]: Service|ServiceFactory }} newServices
-     * @returns
-     */
-    add(namespace, newServices) {
-      for (const serviceName of Object.keys(newServices)) {
-        const service = newServices[serviceName];
-        const uid = addNamespace(serviceName, namespace);
-
-        if (has(uid, services)) {
-          throw new Error(`Service ${uid} has already been registered.`);
-        }
-        services[uid] = service;
-      }
-
-      return this;
-    },
-
-    /**
-     * Wraps a service to extend it
-     * @param {string} uid
-     * @param {(service: Service) => Service} extendFn
-     */
-    extend(uid, extendFn) {
-      const currentService = this.get(uid);
-
-      if (!currentService) {
-        throw new Error(`Service ${uid} doesn't exist`);
-      }
-
-      const newService = extendFn(currentService);
-      instantiatedServices[uid] = newService;
-
-      return this;
-    },
-  };
-};
-
-module.exports = servicesRegistry;

package/lib/core/registries/validators.js

@@ -1,26 +0,0 @@
-'use strict';
-
-const _ = require('lodash');
-
-const validatorsRegistry = () => {
-  const validators = {};
-
-  return {
-    get(path) {
-      return _.get(validators, path, []);
-    },
-    add(path, sanitizer) {
-      this.get(path).push(sanitizer);
-      return this;
-    },
-    set(path, value = []) {
-      _.set(validators, path, value);
-      return this;
-    },
-    has(path) {
-      return _.has(validators, path);
-    },
-  };
-};
-
-module.exports = validatorsRegistry;

package/lib/core/utils.js

@@ -1,32 +0,0 @@
-'use strict';
-
-const hasNamespace = (name, namespace) => {
-  if (!namespace) {
-    return true;
-  }
-
-  if (namespace.endsWith('::')) {
-    return name.startsWith(namespace);
-  }
-  return name.startsWith(`${namespace}.`);
-};
-
-const addNamespace = (name, namespace) => {
-  if (namespace.endsWith('::')) {
-    return `${namespace}${name}`;
-  }
-  return `${namespace}.${name}`;
-};
-
-const removeNamespace = (name, namespace) => {
-  if (namespace.endsWith('::')) {
-    return name.replace(namespace, '');
-  }
-  return name.replace(`${namespace}.`, '');
-};
-
-module.exports = {
-  addNamespace,
-  removeNamespace,
-  hasNamespace,
-};