@akemona-org/strapi 3.7.0

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

@@ -0,0 +1,122 @@
+'use strict';
+
+const { propOr } = require('lodash/fp');
+
+const {
+  hasDraftAndPublish,
+  constants: { PUBLISHED_AT_ATTRIBUTE },
+} = require('@akemona-org/strapi-utils').contentTypes;
+
+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 { modelName } = model;
+
+  const { sanitizeInput, getFetchParams } = utils;
+
+  return {
+    /**
+     * Promise to fetch all records
+     *
+     * @return {Promise}
+     */
+    find(params, populate) {
+      return strapi.entityService.find(
+        { params: getFetchParams(params), populate },
+        { model: modelName }
+      );
+    },
+
+    /**
+     * Promise to fetch record
+     *
+     * @return {Promise}
+     */
+
+    findOne(params, populate) {
+      return strapi.entityService.findOne(
+        { params: getFetchParams(params), populate },
+        { model: modelName }
+      );
+    },
+
+    /**
+     * Promise to count record
+     *
+     * @return {Promise}
+     */
+
+    count(params) {
+      return strapi.entityService.count({ params: getFetchParams(params) }, { model: modelName });
+    },
+
+    /**
+     * Promise to add record
+     *
+     * @return {Promise}
+     */
+
+    create(data, { files } = {}) {
+      const sanitizedData = sanitizeInput(data);
+      if (hasDraftAndPublish(model)) {
+        setPublishedAt(sanitizedData);
+      }
+
+      return strapi.entityService.create({ data: sanitizedData, files }, { model: modelName });
+    },
+
+    /**
+     * Promise to edit record
+     *
+     * @return {Promise}
+     */
+
+    update(params, data, { files } = {}) {
+      const sanitizedData = sanitizeInput(data);
+      return strapi.entityService.update(
+        { params, data: sanitizedData, files },
+        { model: modelName }
+      );
+    },
+
+    /**
+     * Promise to delete a record
+     *
+     * @return {Promise}
+     */
+
+    delete(params) {
+      return strapi.entityService.delete({ params }, { model: modelName });
+    },
+
+    /**
+     * Promise to search records
+     *
+     * @return {Promise}
+     */
+
+    search(params) {
+      return strapi.entityService.search({ params: getFetchParams(params) }, { model: modelName });
+    },
+
+    /**
+     * Promise to count searched records
+     *
+     * @return {Promise}
+     */
+    countSearch(params) {
+      return strapi.entityService.countSearch(
+        { params: getFetchParams(params) },
+        { model: modelName }
+      );
+    },
+  };
+};
+
+module.exports = createCollectionTypeService;

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

@@ -0,0 +1,81 @@
+'use strict';
+
+const _ = require('lodash');
+
+const {
+  isSingleType,
+  getNonWritableAttributes,
+  constants: { DP_PUB_STATE_LIVE },
+} = require('@akemona-org/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 });
+};
+
+/**
+ * Default limit values from config
+ * @return {{maxLimit: number, defaultLimit: number}}
+ */
+const getLimitConfigDefaults = () => ({
+  defaultLimit: _.toNumber(strapi.config.get('api.rest.defaultLimit', 100)),
+  maxLimit: _.toNumber(strapi.config.get('api.rest.maxLimit')) || null,
+});
+
+const getLimitParam = (params) => {
+  const { defaultLimit, maxLimit } = getLimitConfigDefaults();
+
+  if (params._limit === undefined) {
+    return defaultLimit;
+  }
+
+  const limit = _.toNumber(params._limit);
+  // if there is max limit set and params._limit exceeds this number, return configured max limit
+  if (maxLimit && (limit === -1 || limit > maxLimit)) {
+    return maxLimit;
+  }
+
+  return limit;
+};
+
+/**
+ * Create default fetch params
+ * @param {*} params
+ * @returns
+ */
+const getFetchParams = (params = {}) => {
+  return {
+    _publicationState: DP_PUB_STATE_LIVE,
+    ...params,
+    _limit: getLimitParam(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/single-type.js

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

package/lib/hooks/index.js

@@ -0,0 +1,97 @@
+'use strict';
+
+const { uniq, difference, get, isUndefined, merge } = require('lodash');
+
+module.exports = async function() {
+  /** Utils */
+
+  const hookConfig = this.config.hook;
+
+  // check if a hook exists
+  const hookExists = key => {
+    return !isUndefined(this.hook[key]);
+  };
+
+  // check if a hook is enabled
+  const hookEnabled = key => get(hookConfig, ['settings', key, 'enabled'], false) === true;
+
+  // list of enabled hooks
+  const enableddHook = Object.keys(this.hook).filter(hookEnabled);
+
+  // Method to initialize hooks and emit an event.
+  const initialize = hookKey => {
+    if (this.hook[hookKey].loaded === true) return;
+
+    const module = this.hook[hookKey].load;
+    const hookTimeout = get(hookConfig, ['settings', hookKey, 'timeout'], hookConfig.timeout);
+
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(
+        () => reject(`(hook: ${hookKey}) is taking too long to load.`),
+        hookTimeout || 1000
+      );
+
+      this.hook[hookKey] = merge(this.hook[hookKey], module);
+
+      Promise.resolve()
+        .then(() => module.initialize())
+        .then(() => {
+          clearTimeout(timeout);
+          this.hook[hookKey].loaded = true;
+          resolve();
+        })
+        .catch(err => {
+          clearTimeout(timeout);
+
+          if (err) {
+            return reject(err);
+          }
+        });
+    });
+  };
+
+  /**
+   * Run init functions
+   */
+
+  // Run beforeInitialize of every hook
+  await Promise.all(
+    enableddHook.map(key => {
+      const { beforeInitialize } = this.hook[key].load;
+      if (typeof beforeInitialize === 'function') {
+        return beforeInitialize();
+      }
+    })
+  );
+
+  // run the initialization of an array of hooks sequentially
+  const initdHookSeq = async hookArr => {
+    for (let key of uniq(hookArr)) {
+      await initialize(key);
+    }
+  };
+
+  const hooksBefore = get(hookConfig, 'load.before', [])
+    .filter(hookExists)
+    .filter(hookEnabled);
+
+  const hooksAfter = get(hookConfig, 'load.after', [])
+    .filter(hookExists)
+    .filter(hookEnabled);
+
+  const hooksOrder = get(hookConfig, 'load.order', [])
+    .filter(hookExists)
+    .filter(hookEnabled);
+
+  const unspecifieddHook = difference(enableddHook, hooksBefore, hooksOrder, hooksAfter);
+
+  // before
+  await initdHookSeq(hooksBefore);
+
+  // ordered // rest of hooks
+  await initdHookSeq(hooksOrder);
+  await initdHookSeq(unspecifieddHook);
+
+  // after
+  await initdHookSeq(hooksAfter);
+};

package/lib/index.js

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

package/lib/load/check-reserved-filename.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const _ = require('lodash');
+
+// files to load with filename key
+const prefixedPaths = [
+  'functions',
+  'policies',
+  'locales',
+  'hook',
+  'middleware',
+  'language',
+  'layout',
+];
+
+module.exports = function checkReservedFilenames(file) {
+  return _.some(prefixedPaths, e => file.indexOf(`config/${e}`) >= 0) ? true : false;
+};

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-config-files.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const loadFiles = require('./load-files');
+const requireFileAndParse = require('./require-file-parse');
+const checkReservedFilename = require('./check-reserved-filename');
+
+/**
+ * @param {string} dir - directory from which to load configs
+ * @param {string} pattern - glob pattern to search for config files
+ */
+const loadConfigFiles = (dir, pattern = 'config/**/*.+(js|json)') =>
+  loadFiles(dir, pattern, {
+    requireFn: requireFileAndParse,
+    shouldUseFileNameAsKey: checkReservedFilename,
+    globArgs: {
+      // used to load .init.json at first startup
+      dot: true,
+      ignore: ['config/**/*.test.js'],
+    },
+  });
+
+module.exports = loadConfigFiles;

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/load/require-file-parse.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const path = require('path');
+const { templateConfiguration } = require('@akemona-org/strapi-utils');
+
+/**
+ * Requires a file and eval expression if it is a json
+ * @param {string} filePath - file path
+ */
+module.exports = (filePath) => {
+  if (path.extname(filePath) === '.json') {
+    return templateConfiguration(require(filePath));
+  }
+  return require(filePath);
+};

package/lib/middlewares/boom/defaults.json

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

package/lib/middlewares/boom/index.js

@@ -0,0 +1,147 @@
+'use strict';
+
+/**
+ * Boom hook
+ */
+
+// Public node modules.
+const _ = require('lodash');
+const Boom = require('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.app.context, 'response');
+      this.createResponses();
+
+      strapi.errors = Boom;
+      strapi.app.use(async (ctx, next) => {
+        try {
+          // App logic.
+          await next();
+        } catch (error) {
+          // emit error if configured
+          if (strapi.config.get('server.emitErrors', false)) {
+            strapi.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.app.use(async (ctx, next) => {
+        await next();
+        // Empty body is considered as `notFound` response.
+        if (_.isNil(ctx.body) && _.isNil(ctx.status)) {
+          ctx.notFound();
+        }
+      });
+    },
+
+    // Custom function to avoid ctx.body repeat
+    createResponses() {
+      boomMethods.forEach(method => {
+        strapi.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.app.response.send = function(data, status = 200) {
+        this.status = status;
+        this.body = data;
+      };
+
+      strapi.app.response.created = function(data) {
+        this.status = 201;
+        this.body = data;
+      };
+
+      strapi.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');
+    },
+  };
+};