@strapi/strapi 4.0.0-beta.0

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

@@ -0,0 +1,55 @@
+'use strict';
+
+const _ = require('lodash');
+
+const {
+  isSingleType,
+  getNonWritableAttributes,
+  constants: { DP_PUB_STATE_LIVE },
+} = require('@strapi/utils').contentTypes;
+
+const createSingleTypeService = require('./single-type');
+const createCollectionTypeService = require('./collection-type');
+
+/**
+ * Returns a core api for the provided model
+ * @param {{ model: object, strapi: object }} context
+ * @returns {object}
+ */
+const createService = ({ model, strapi }) => {
+  const utils = createUtils({ model });
+
+  if (isSingleType(model)) {
+    return createSingleTypeService({ model, strapi, utils });
+  }
+
+  return createCollectionTypeService({ model, strapi, utils });
+};
+
+/**
+ * Create default fetch params
+ * @param {*} params
+ * @returns
+ */
+const getFetchParams = (params = {}) => {
+  return {
+    publicationState: DP_PUB_STATE_LIVE,
+    ...params,
+  };
+};
+
+/**
+ * Mixins
+ */
+const createUtils = ({ model }) => {
+  return {
+    // make sure to keep the call to getNonWritableAttributes dynamic
+    sanitizeInput: data => _.omit(data, getNonWritableAttributes(model)),
+    getFetchParams,
+  };
+};
+
+module.exports = {
+  createService,
+  getFetchParams,
+};

package/lib/core-api/service/pagination.js

@@ -0,0 +1,125 @@
+'use strict';
+
+const { has, toNumber, isUndefined } = require('lodash/fp');
+
+/**
+ * Default limit values from config
+ * @return {{maxLimit: number, defaultLimit: number}}
+ */
+const getLimitConfigDefaults = () => ({
+  defaultLimit: toNumber(strapi.config.get('api.rest.defaultLimit', 25)),
+  maxLimit: toNumber(strapi.config.get('api.rest.maxLimit')) || null,
+});
+
+/**
+ * if there is max limit set and limit exceeds this number, return configured max limit
+ * @param {number} limit - limit you want to cap
+ * @param {number?} maxLimit - maxlimit used has capping
+ * @returns {number}
+ */
+const applyMaxLimit = (limit, maxLimit) => {
+  if (maxLimit && (limit === -1 || limit > maxLimit)) {
+    return maxLimit;
+  }
+
+  return limit;
+};
+
+const shouldCount = params => {
+  if (has('pagination.withCount', params)) {
+    const { withCount } = params.pagination;
+
+    if (typeof withCount === 'boolean') {
+      return withCount;
+    }
+
+    if (['true', 't', '1', 1].includes(withCount)) {
+      return true;
+    }
+
+    if (['false', 'f', '0', 0].includes(withCount)) {
+      return false;
+    }
+
+    throw new Error('Invalid withCount parameter. Expected "t","1","true","false","0","f"');
+  }
+
+  return Boolean(strapi.config.get('api.rest.withCount', true));
+};
+
+const isOffsetPagination = pagination => has('start', pagination) || has('limit', pagination);
+const isPagedPagination = pagination => has('page', pagination) || has('pageSize', pagination);
+
+const getPaginationInfo = params => {
+  const { defaultLimit, maxLimit } = getLimitConfigDefaults();
+
+  const { pagination } = params;
+
+  const isPaged = isPagedPagination(pagination);
+  const isOffset = isOffsetPagination(pagination);
+
+  if (!isPaged && !isOffset) {
+    return {
+      page: 1,
+      pageSize: defaultLimit,
+    };
+  }
+
+  if (isOffset && isPaged) {
+    throw new Error('Invalid pagination parameters. Expected either start/limit or page/pageSize');
+  }
+
+  if (isPagedPagination(pagination)) {
+    const pageSize = isUndefined(pagination.pageSize)
+      ? defaultLimit
+      : Math.max(1, toNumber(pagination.pageSize));
+
+    return {
+      page: Math.max(1, toNumber(pagination.page || 1)),
+      pageSize: applyMaxLimit(pageSize, maxLimit),
+    };
+  }
+
+  const limit = isUndefined(pagination.limit)
+    ? defaultLimit
+    : Math.max(1, toNumber(pagination.limit));
+
+  return {
+    start: Math.max(0, toNumber(pagination.start || 0)),
+    limit: applyMaxLimit(limit, maxLimit),
+  };
+};
+
+const convertPagedToStartLimit = pagination => {
+  if (isPagedPagination(pagination)) {
+    const { page, pageSize } = pagination;
+    return {
+      start: (page - 1) * pageSize,
+      limit: pageSize,
+    };
+  }
+
+  return pagination;
+};
+
+const transformPaginationResponse = (paginationInfo, count) => {
+  if (paginationInfo.page) {
+    return {
+      ...paginationInfo,
+      pageCount: Math.ceil(count / paginationInfo.pageSize),
+      total: count,
+    };
+  }
+
+  return {
+    ...paginationInfo,
+    total: count,
+  };
+};
+
+module.exports = {
+  getPaginationInfo,
+  convertPagedToStartLimit,
+  transformPaginationResponse,
+  shouldCount,
+};

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

@@ -0,0 +1,58 @@
+'use strict';
+
+/**
+ * Returns a single type service to handle default core-api actions
+ */
+const createSingleTypeService = ({ model, strapi, utils }) => {
+  const { uid } = model;
+  const { sanitizeInput, getFetchParams } = utils;
+
+  return {
+    /**
+     * Returns singleType content
+     *
+     * @return {Promise}
+     */
+    find(params = {}) {
+      return strapi.entityService.findMany(uid, getFetchParams(params));
+    },
+
+    /**
+     * Creates or updates a singleType content
+     *
+     * @return {Promise}
+     */
+    async createOrUpdate(params = {}) {
+      const entity = await this.find(params);
+
+      const { data } = params;
+      const sanitizedData = sanitizeInput(data);
+
+      if (!entity) {
+        const count = await strapi.query(uid).count();
+        if (count >= 1) {
+          throw strapi.errors.badRequest('singleType.alreadyExists');
+        }
+
+        return strapi.entityService.create(uid, { ...params, data: sanitizedData });
+      }
+
+      return strapi.entityService.update(uid, entity.id, { ...params, data: sanitizedData });
+    },
+
+    /**
+     * Deletes the singleType content
+     *
+     * @return {Promise}
+     */
+    async delete(params = {}) {
+      const entity = await this.find(params);
+
+      if (!entity) return;
+
+      return strapi.entityService.delete(uid, entity.id);
+    },
+  };
+};
+
+module.exports = createSingleTypeService;

package/lib/index.d.ts

@@ -0,0 +1,26 @@
+import { Database } from '@strapi/database';
+import { EntityService } from './services/entity-service';
+import { Strapi as StrapiClass } from './Strapi';
+
+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 default function(opts): Strapi;

package/lib/index.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./Strapi');

package/lib/load/filepath-to-prop-path.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const _ = require('lodash');
+
+/**
+ * Returns a path (as an array) from a file path
+ * @param {string} filePath - a file path
+ * @param {boolean} useFileNameAsKey - wethear to skip the last path key
+ */
+module.exports = (filePath, useFileNameAsKey = true) => {
+  let cleanPath = filePath.startsWith('./') ? filePath.slice(2) : filePath;
+
+  const prop = cleanPath
+    .replace(/(\.settings|\.json|\.js)/g, '')
+    .toLowerCase()
+    .split('/')
+    .map(p => _.trimStart(p, '.'))
+    .join('.')
+    .split('.');
+
+  return useFileNameAsKey === true ? prop : prop.slice(0, -1);
+};

package/lib/load/glob.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const glob = require('glob');
+
+/**
+ * Promise based glob
+ */
+module.exports = (...args) => {
+  return new Promise((resolve, reject) => {
+    glob(...args, (err, files) => {
+      if (err) return reject(err);
+      resolve(files);
+    });
+  });
+};

package/lib/load/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const loadFiles = require('./load-files');
+const findPackagePath = require('./package-path');
+
+module.exports = {
+  loadFiles,
+  findPackagePath,
+};

package/lib/load/load-files.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const path = require('path');
+const _ = require('lodash');
+const fse = require('fs-extra');
+const glob = require('./glob');
+const filePathToPath = require('./filepath-to-prop-path');
+
+/**
+ * Returns an Object build from a list of files matching a glob pattern in a directory
+ * It builds a tree structure resembling the folder structure in dir
+ * @param {string} dir - Directory to load
+ * @param {string} pattern - Glob pattern to search for
+ * @param {Object} options - Options
+ * @param {Function} options.requireFn - Function that will require the matches files
+ * @param {Function} options.shouldUseFileNameAsKey - Weather to use the filename as a key in the Object path or not
+ * @param {Object} options.globArgs - extra glob function arguments
+ */
+const loadFiles = async (
+  dir,
+  pattern,
+  { requireFn = require, shouldUseFileNameAsKey = () => true, globArgs = {} } = {}
+) => {
+  const root = {};
+  const files = await glob(pattern, { cwd: dir, ...globArgs });
+
+  for (let file of files) {
+    const absolutePath = path.resolve(dir, file);
+
+    // load module
+    delete require.cache[absolutePath];
+    let mod;
+
+    if (path.extname(absolutePath) === '.json') {
+      mod = await fse.readJson(absolutePath);
+    } else {
+      mod = requireFn(absolutePath);
+    }
+
+    Object.defineProperty(mod, '__filename__', {
+      enumerable: true,
+      configurable: false,
+      writable: false,
+      value: path.basename(file),
+    });
+
+    const propPath = filePathToPath(file, shouldUseFileNameAsKey(file));
+
+    if (propPath.length === 0) _.merge(root, mod);
+    _.merge(root, _.setWith({}, propPath, mod, Object));
+  }
+
+  return root;
+};
+
+module.exports = loadFiles;

package/lib/load/package-path.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const path = require('path');
+
+/**
+ * Returns the path to a node modules root directory (not the main file path)
+ * @param {string} moduleName - name of a node module
+ */
+module.exports = moduleName => path.dirname(require.resolve(`${moduleName}/package.json`));

package/lib/middlewares/cors/index.js

@@ -0,0 +1,66 @@
+'use strict';
+
+/**
+ * Module dependencies
+ */
+const cors = require('@koa/cors');
+
+const defaults = {
+  origin: '*',
+  maxAge: 31536000,
+  credentials: true,
+  methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS'],
+  headers: ['Content-Type', 'Authorization', 'Origin', 'Accept'],
+  keepHeadersOnError: false,
+};
+
+module.exports = strapi => {
+  return {
+    /**
+     * Initialize the hook
+     */
+    initialize() {
+      const {
+        origin,
+        expose,
+        maxAge,
+        credentials,
+        methods,
+        headers,
+        keepHeadersOnError,
+      } = Object.assign({}, defaults, strapi.config.get('middleware.settings.cors'));
+
+      strapi.server.use(
+        cors({
+          async origin(ctx) {
+            let originList;
+
+            if (typeof origin === 'function') {
+              originList = await origin(ctx);
+            } else {
+              originList = origin;
+            }
+
+            const whitelist = Array.isArray(originList) ? originList : originList.split(/\s*,\s*/);
+
+            const requestOrigin = ctx.accept.headers.origin;
+            if (whitelist.includes('*')) {
+              return '*';
+            }
+
+            if (!whitelist.includes(requestOrigin)) {
+              return ctx.throw(`${requestOrigin} is not a valid origin`);
+            }
+            return requestOrigin;
+          },
+          exposeHeaders: expose,
+          maxAge,
+          credentials,
+          allowMethods: methods,
+          allowHeaders: headers,
+          keepHeadersOnError,
+        })
+      );
+    },
+  };
+};

package/lib/middlewares/error/defaults.json

@@ -0,0 +1,5 @@
+{
+  "error": {
+    "enabled": true
+  }
+}

package/lib/middlewares/error/index.js

@@ -0,0 +1,147 @@
+'use strict';
+
+/**
+ * Boom hook
+ */
+
+// Public node modules.
+const _ = require('lodash');
+const Boom = require('@hapi/boom');
+const delegate = require('delegates');
+
+const boomMethods = [
+  'badRequest',
+  'unauthorized',
+  'paymentRequired',
+  'forbidden',
+  'notFound',
+  'methodNotAllowed',
+  'notAcceptable',
+  'proxyAuthRequired',
+  'clientTimeout',
+  'conflict',
+  'resourceGone',
+  'lengthRequired',
+  'preconditionFailed',
+  'entityTooLarge',
+  'uriTooLong',
+  'unsupportedMediaType',
+  'rangeNotSatisfiable',
+  'expectationFailed',
+  'teapot',
+  'badData',
+  'locked',
+  'failedDependency',
+  'preconditionRequired',
+  'tooManyRequests',
+  'illegal',
+  'badImplementation',
+  'notImplemented',
+  'badGateway',
+  'serverUnavailable',
+  'gatewayTimeout',
+];
+
+const formatBoomPayload = boomError => {
+  if (!Boom.isBoom(boomError)) {
+    boomError = Boom.boomify(boomError, {
+      statusCode: boomError.status || 500,
+    });
+  }
+
+  const { output } = boomError;
+
+  if (output.statusCode < 500 && !_.isNil(boomError.data)) {
+    output.payload.data = boomError.data;
+  }
+
+  return { status: output.statusCode, body: output.payload };
+};
+
+module.exports = strapi => {
+  return {
+    /**
+     * Initialize the hook
+     */
+
+    initialize() {
+      this.delegator = delegate(strapi.server.app.context, 'response');
+      this.createResponses();
+
+      strapi.errors = Boom;
+      strapi.server.use(async (ctx, next) => {
+        try {
+          // App logic.
+          await next();
+        } catch (error) {
+          // emit error if configured
+          if (strapi.config.get('server.emitErrors', false)) {
+            strapi.server.app.emit('error', error, ctx);
+          }
+
+          // Log error.
+
+          const { status, body } = formatBoomPayload(error);
+
+          if (status >= 500) {
+            strapi.log.error(error);
+          }
+
+          ctx.body = body;
+          ctx.status = status;
+        }
+      });
+
+      strapi.server.use(async (ctx, next) => {
+        await next();
+        // Empty body is considered as `notFound` response.
+        if (_.isNil(ctx.body) && (_.isNil(ctx.status) || ctx.status === 404)) {
+          ctx.notFound();
+        }
+      });
+    },
+
+    // Custom function to avoid ctx.body repeat
+    createResponses() {
+      boomMethods.forEach(method => {
+        strapi.server.app.response[method] = function(msg, ...rest) {
+          const boomError = Boom[method](msg, ...rest) || {};
+
+          const { status, body } = formatBoomPayload(boomError);
+
+          // keep retro-compatibility for old error formats
+          body.message = msg || body.data || body.message;
+
+          this.body = body;
+          this.status = status;
+        };
+
+        this.delegator.method(method);
+      });
+
+      strapi.server.app.response.send = function(data, status = 200) {
+        this.status = status;
+        this.body = data;
+      };
+
+      strapi.server.app.response.created = function(data) {
+        this.status = 201;
+        this.body = data;
+      };
+
+      strapi.server.app.response.deleted = function(data) {
+        if (_.isNil(data)) {
+          this.status = 204;
+        } else {
+          this.status = 200;
+          this.body = data;
+        }
+      };
+
+      this.delegator
+        .method('send')
+        .method('created')
+        .method('deleted');
+    },
+  };
+};

package/lib/middlewares/favicon/defaults.json

@@ -0,0 +1,7 @@
+{
+  "favicon": {
+    "enabled": true,
+    "path": "favicon.ico",
+    "maxAge": 86400000
+  }
+}

package/lib/middlewares/favicon/index.js

@@ -0,0 +1,31 @@
+'use strict';
+
+/**
+ * Module dependencies
+ */
+
+// Node.js core.
+const { resolve } = require('path');
+const favicon = require('koa-favicon');
+
+/**
+ * Favicon hook
+ */
+
+module.exports = strapi => {
+  return {
+    /**
+     * Initialize the hook
+     */
+
+    initialize() {
+      const { maxAge, path: faviconPath } = strapi.config.middleware.settings.favicon;
+
+      strapi.server.use(
+        favicon(resolve(strapi.dirs.root, faviconPath), {
+          maxAge,
+        })
+      );
+    },
+  };
+};

package/lib/middlewares/gzip/defaults.json

@@ -0,0 +1,6 @@
+{
+  "gzip": {
+    "enabled": false,
+    "options": {}
+  }
+}

package/lib/middlewares/gzip/index.js

@@ -0,0 +1,19 @@
+'use strict';
+
+/**
+ * Gzip hook
+ */
+const compress = require('koa-compress');
+
+module.exports = strapi => {
+  return {
+    /**
+     * Initialize the hook
+     */
+
+    initialize() {
+      const { options = {} } = strapi.config.middleware.settings.gzip;
+      strapi.server.use(compress(options));
+    },
+  };
+};

package/lib/middlewares/helmet/defaults.json

@@ -0,0 +1,18 @@
+{
+  "helmet": {
+    "enabled": true,
+    "crossOriginEmbedderPolicy": false,
+    "crossOriginOpenerPolicy": false,
+    "crossOriginResourcePolicy": false,
+    "originAgentCluster": false,
+    "contentSecurityPolicy": false,
+    "xssFilter": false,
+    "hsts": {
+      "maxAge": 31536000,
+      "includeSubDomains": true
+    },
+    "frameguard": {
+      "action": "sameorigin"
+    }
+  }
+}