@strapi/strapi 4.0.0-beta.0

package/lib/core/registries/controllers.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const { pickBy, has } = require('lodash/fp');
+const { addNamespace, hasNamespace } = require('../utils');
+
+const controllersRegistry = () => {
+  const controllers = {};
+
+  return {
+    get(uid) {
+      return controllers[uid];
+    },
+    getAll(namespace) {
+      return pickBy((_, uid) => hasNamespace(uid, namespace))(controllers);
+    },
+    set(uid, value) {
+      controllers[uid] = value;
+      return this;
+    },
+    add(namespace, newControllers) {
+      for (const controllerName in newControllers) {
+        const controller = newControllers[controllerName];
+        const uid = addNamespace(controllerName, namespace);
+
+        if (has(uid, controllers)) {
+          throw new Error(`Controller ${uid} has already been registered.`);
+        }
+        controllers[uid] = controller;
+      }
+      return this;
+    },
+    extend(controllerUID, extendFn) {
+      const currentController = this.get(controllerUID);
+      if (!currentController) {
+        throw new Error(`Controller ${controllerUID} doesn't exist`);
+      }
+      const newController = extendFn(currentController);
+      controllers[controllerUID] = newController;
+    },
+  };
+};
+
+module.exports = controllersRegistry;

package/lib/core/registries/hooks.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const { pickBy, has } = require('lodash/fp');
+const { addNamespace, hasNamespace } = require('../utils');
+
+const hooksRegistry = () => {
+  const hooks = {};
+
+  return {
+    get(hookUID) {
+      return hooks[hookUID];
+    },
+    getAll(namespace) {
+      return pickBy((_, uid) => hasNamespace(uid, namespace))(hooks);
+    },
+    set(uid, hook) {
+      if (has(uid, hooks)) {
+        throw new Error(`hook ${uid} has already been registered.`);
+      }
+
+      hooks[uid] = hook;
+      return this;
+    },
+    add(namespace, hooks) {
+      for (const hookName in hooks) {
+        const hook = hooks[hookName];
+        const uid = addNamespace(hookName, namespace);
+
+        this.set(uid, hook);
+      }
+
+      return this;
+    },
+  };
+};
+
+module.exports = hooksRegistry;

package/lib/core/registries/middlewares.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const { pickBy, has } = require('lodash/fp');
+const { addNamespace, hasNamespace } = require('../utils');
+
+const middlewaresRegistry = () => {
+  const middlewares = {};
+
+  return {
+    get(middlewareUID) {
+      return middlewares[middlewareUID];
+    },
+    getAll(namespace) {
+      return pickBy((_, uid) => hasNamespace(uid, namespace))(middlewares);
+    },
+    add(namespace, rawMiddlewares) {
+      for (const middlewareName in 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;
+      }
+    },
+  };
+};
+
+module.exports = middlewaresRegistry;

package/lib/core/registries/modules.js

@@ -0,0 +1,44 @@
+'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

@@ -0,0 +1,28 @@
+'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.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const { pickBy, has } = require('lodash/fp');
+const { addNamespace, hasNamespace } = require('../utils');
+
+const policiesRegistry = () => {
+  const policies = {};
+
+  return {
+    get(policyUID) {
+      return policies[policyUID];
+    },
+    getAll(namespace) {
+      return pickBy((_, uid) => hasNamespace(uid, namespace))(policies);
+    },
+    add(namespace, newPolicies) {
+      for (const policyName in 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;
+      }
+    },
+    extend(policyUID, extendFn) {
+      const currentPolicy = this.get(policyUID);
+      if (!currentPolicy) {
+        throw new Error(`Policy ${policyUID} doesn't exist`);
+      }
+      const newPolicy = extendFn(currentPolicy);
+      policies[policyUID] = newPolicy;
+    },
+  };
+};
+
+module.exports = policiesRegistry;

package/lib/core/registries/services.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const _ = require('lodash');
+const { pickBy, has } = require('lodash/fp');
+const { addNamespace, hasNamespace } = require('../utils');
+
+const servicesRegistry = strapi => {
+  const services = {};
+  const instantiatedServices = {};
+
+  return {
+    get(uid) {
+      if (instantiatedServices[uid]) {
+        return instantiatedServices[uid];
+      }
+
+      const service = services[uid];
+      if (service) {
+        instantiatedServices[uid] = service({ strapi });
+        return instantiatedServices[uid];
+      }
+
+      return undefined;
+    },
+    getAll(namespace) {
+      const filteredServices = pickBy((_, uid) => hasNamespace(uid, namespace))(services);
+
+      return _.mapValues(filteredServices, (service, serviceUID) => this.get(serviceUID));
+    },
+    set(uid, value) {
+      instantiatedServices[uid] = value;
+      return this;
+    },
+    add(namespace, newServices) {
+      for (const serviceName in 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;
+    },
+    extend(serviceUID, extendFn) {
+      const currentService = this.get(serviceUID);
+      if (!currentService) {
+        throw new Error(`Service ${serviceUID} doesn't exist`);
+      }
+      const newService = extendFn(currentService);
+      instantiatedServices[serviceUID] = newService;
+    },
+  };
+};
+
+module.exports = servicesRegistry;

package/lib/core/utils.js

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

package/lib/core-api/controller/collection-type.js

@@ -0,0 +1,84 @@
+'use strict';
+
+const { parseBody } = require('./transform');
+
+/**
+ *
+ * Returns a collection type controller to handle default core-api actions
+ */
+const createCollectionTypeController = ({ service, sanitize, transformResponse }) => {
+  return {
+    /**
+     * Retrieve records.
+     *
+     * @return {Object|Array}
+     */
+    async find(ctx) {
+      const { query } = ctx;
+
+      const { results, pagination } = await service.find(query);
+
+      return transformResponse(sanitize(results), { pagination });
+    },
+
+    /**
+     * Retrieve a record.
+     *
+     * @return {Object}
+     */
+    async findOne(ctx) {
+      const { id } = ctx.params;
+      const { query } = ctx;
+
+      const entity = await service.findOne(id, query);
+
+      return transformResponse(sanitize(entity));
+    },
+
+    /**
+     * Create a record.
+     *
+     * @return {Object}
+     */
+    async create(ctx) {
+      const { query } = ctx.request;
+
+      const { data, files } = parseBody(ctx);
+
+      const entity = await service.create({ ...query, data, files });
+
+      return transformResponse(sanitize(entity));
+    },
+
+    /**
+     * Update a record.
+     *
+     * @return {Object}
+     */
+    async update(ctx) {
+      const { id } = ctx.params;
+      const { query } = ctx.request;
+
+      const { data, files } = parseBody(ctx);
+
+      const entity = await service.update(id, { ...query, data, files });
+
+      return transformResponse(sanitize(entity));
+    },
+
+    /**
+     * Destroy a record.
+     *
+     * @return {Object}
+     */
+    async delete(ctx) {
+      const { id } = ctx.params;
+      const { query } = ctx;
+
+      const entity = await service.delete(id, query);
+      return transformResponse(sanitize(entity));
+    },
+  };
+};
+
+module.exports = createCollectionTypeController;

package/lib/core-api/controller/index.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const { sanitizeEntity, contentTypes } = require('@strapi/utils');
+
+const { transformResponse } = require('./transform');
+const createSingleTypeController = require('./single-type');
+const createCollectionTypeController = require('./collection-type');
+
+module.exports = ({ service, model }) => {
+  const ctx = {
+    model,
+    service,
+    transformResponse(data, meta) {
+      return transformResponse(data, meta, { contentType: model });
+    },
+    sanitize(data) {
+      return sanitizeEntity(data, { model: strapi.getModel(model.uid) });
+    },
+  };
+
+  if (contentTypes.isSingleType(model)) {
+    return createSingleTypeController(ctx);
+  }
+
+  return createCollectionTypeController(ctx);
+};

package/lib/core-api/controller/single-type.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const { parseBody } = require('./transform');
+
+/**
+ * Returns a single type controller to handle default core-api actions
+ */
+const createSingleTypeController = ({ service, sanitize, transformResponse }) => {
+  return {
+    /**
+     * Retrieve single type content
+     *
+     * @return {Object|Array}
+     */
+    async find(ctx) {
+      const { query } = ctx;
+      const entity = await service.find(query);
+      return transformResponse(sanitize(entity));
+    },
+
+    /**
+     * create or update single type content.
+     *
+     * @return {Object}
+     */
+    async update(ctx) {
+      const { query } = ctx.request;
+      const { data, files } = parseBody(ctx);
+
+      const entity = await service.createOrUpdate({ ...query, data, files });
+
+      return transformResponse(sanitize(entity));
+    },
+
+    async delete(ctx) {
+      const { query } = ctx;
+
+      const entity = await service.delete(query);
+      return transformResponse(sanitize(entity));
+    },
+  };
+};
+
+module.exports = createSingleTypeController;

package/lib/core-api/controller/transform.js

@@ -0,0 +1,97 @@
+'use strict';
+
+const { isNil, isPlainObject } = require('lodash/fp');
+const { parseMultipartData } = require('@strapi/utils');
+
+const parseBody = ctx => {
+  if (ctx.is('multipart')) {
+    return parseMultipartData(ctx);
+  }
+
+  const { data } = ctx.request.body || {};
+
+  return { data };
+};
+
+const transformResponse = (resource, meta = {}, { contentType } = {}) => {
+  if (isNil(resource)) {
+    return resource;
+  }
+
+  return {
+    data: transformEntry(resource, contentType),
+    meta,
+  };
+};
+
+const transformComponent = (data, component) => {
+  if (Array.isArray(data)) {
+    return data.map(datum => transformComponent(datum, component));
+  }
+
+  const res = transformEntry(data, component);
+
+  if (isNil(res)) {
+    return res;
+  }
+
+  const { id, attributes } = res;
+  return { id, ...attributes };
+};
+
+const transformEntry = (entry, type) => {
+  if (isNil(entry)) {
+    return entry;
+  }
+
+  if (Array.isArray(entry)) {
+    return entry.map(singleEntry => transformEntry(singleEntry, type));
+  }
+
+  if (!isPlainObject(entry)) {
+    throw new Error('Entry must be an object');
+  }
+
+  const { id, ...properties } = entry;
+
+  const attributeValues = {};
+
+  for (const key in properties) {
+    const property = properties[key];
+    const attribute = type && type.attributes[key];
+
+    if (attribute && attribute.type === 'relation') {
+      const data = transformEntry(property, strapi.contentType(attribute.target));
+
+      attributeValues[key] = { data };
+    } else if (attribute && attribute.type === 'component') {
+      attributeValues[key] = transformComponent(property, strapi.components[attribute.component]);
+    } else if (attribute && attribute.type === 'dynamiczone') {
+      if (isNil(property)) {
+        attributeValues[key] = property;
+      }
+
+      attributeValues[key] = property.map(subProperty => {
+        return transformComponent(subProperty, strapi.components[subProperty.__component]);
+      });
+    } else if (attribute && attribute.type === 'media') {
+      const data = transformEntry(property, strapi.contentType('plugin::upload.file'));
+
+      attributeValues[key] = { data };
+    } else {
+      attributeValues[key] = property;
+    }
+  }
+
+  return {
+    id,
+    attributes: attributeValues,
+    // NOTE: not necessary for now
+    // meta: {},
+  };
+};
+
+module.exports = {
+  parseBody,
+  transformResponse,
+};

package/lib/core-api/index.js

@@ -0,0 +1,39 @@
+/**
+ * Core API
+ */
+'use strict';
+
+const _ = require('lodash');
+
+const createController = require('./controller');
+const { createService } = require('./service');
+
+/**
+ * Returns a service and a controller built based on the content type passed
+ *
+ * @param {object} opts options
+ * @param {object} opts.api api
+ * @param {object} opts.model model
+ * @param {object} opts.strapi strapi
+ * @returns {object} controller & service
+ */
+function createCoreApi({ api, model, strapi }) {
+  const { modelName } = model;
+
+  // find corresponding service and controller
+  const userService = _.get(api, ['services', modelName], {});
+  const userController = _.get(api, ['controllers', modelName], {});
+
+  const service = Object.assign(createService({ model, strapi }), userService);
+
+  const controller = Object.assign(createController({ service, model }), userController);
+
+  return {
+    service,
+    controller,
+  };
+}
+
+module.exports = {
+  createCoreApi,
+};

package/lib/core-api/service/collection-type.js

@@ -0,0 +1,84 @@
+'use strict';
+
+const { propOr } = require('lodash/fp');
+
+const {
+  hasDraftAndPublish,
+  constants: { PUBLISHED_AT_ATTRIBUTE },
+} = require('@strapi/utils').contentTypes;
+
+const {
+  getPaginationInfo,
+  convertPagedToStartLimit,
+  shouldCount,
+  transformPaginationResponse,
+} = require('./pagination');
+
+const setPublishedAt = data => {
+  data[PUBLISHED_AT_ATTRIBUTE] = propOr(new Date(), PUBLISHED_AT_ATTRIBUTE, data);
+};
+
+/**
+ *
+ * Returns a collection type service to handle default core-api actions
+ */
+const createCollectionTypeService = ({ model, strapi, utils }) => {
+  const { uid } = model;
+
+  const { sanitizeInput, getFetchParams } = utils;
+
+  return {
+    async find(params = {}) {
+      const fetchParams = getFetchParams(params);
+
+      const paginationInfo = getPaginationInfo(fetchParams);
+
+      const results = await strapi.entityService.findMany(uid, {
+        ...fetchParams,
+        ...convertPagedToStartLimit(paginationInfo),
+      });
+
+      if (shouldCount(fetchParams)) {
+        const count = await strapi.entityService.count(uid, { ...fetchParams, ...paginationInfo });
+
+        return {
+          results,
+          pagination: transformPaginationResponse(paginationInfo, count),
+        };
+      }
+
+      return {
+        results,
+        pagination: paginationInfo,
+      };
+    },
+
+    findOne(entityId, params = {}) {
+      return strapi.entityService.findOne(uid, entityId, getFetchParams(params));
+    },
+
+    create(params = {}) {
+      const { data } = params;
+      const sanitizedData = sanitizeInput(data);
+
+      if (hasDraftAndPublish(model)) {
+        setPublishedAt(sanitizedData);
+      }
+
+      return strapi.entityService.create(uid, { ...params, data: sanitizedData });
+    },
+
+    update(entityId, params = {}) {
+      const { data } = params;
+      const sanitizedData = sanitizeInput(data);
+
+      return strapi.entityService.update(uid, entityId, { ...params, data: sanitizedData });
+    },
+
+    delete(entityId, params = {}) {
+      return strapi.entityService.delete(uid, entityId, params);
+    },
+  };
+};
+
+module.exports = createCollectionTypeService;