@akemona-org/strapi 3.7.0

package/lib/core/load-hooks.js

@@ -0,0 +1,117 @@
+'use strict';
+
+// Dependencies.
+const path = require('path');
+const fs = require('fs-extra');
+const _ = require('lodash');
+const glob = require('../load/glob');
+const findPackagePath = require('../load/package-path');
+
+/**
+ * Load hooks
+ */
+module.exports = async function({ installedHooks, installedPlugins, appPath }) {
+  let hooks = {};
+
+  await Promise.all([
+    loadHookDependencies(installedHooks, hooks),
+    // local middleware
+    loadLocalHooks(appPath, hooks),
+    // admin hooks
+    loadAdminHooks(hooks),
+    // plugins middlewares
+    loadPluginsHooks(installedPlugins, hooks),
+    // local plugin middlewares
+    loadLocalPluginsHooks(appPath, hooks),
+  ]);
+
+  return hooks;
+};
+
+const loadHooksInDir = async (dir, hooks) => {
+  const files = await glob('*/*(index|defaults).*(js|json)', {
+    cwd: dir,
+  });
+
+  files.forEach(f => {
+    const name = f.split('/')[0];
+    mountHooks(name, [path.resolve(dir, f)], hooks);
+  });
+};
+
+const loadLocalHooks = (appPath, hooks) => loadHooksInDir(path.resolve(appPath, 'hooks'), hooks);
+
+const loadPluginsHooks = async (plugins, hooks) => {
+  for (let pluginName of plugins) {
+    const dir = path.resolve(findPackagePath(`strapi-plugin-${pluginName}`), 'hooks');
+    await loadHooksInDir(dir, hooks);
+  }
+};
+
+const loadAdminHooks = async hooks => {
+  const hooksDir = 'hooks';
+  const dir = path.resolve(findPackagePath('strapi-admin'), hooksDir);
+  await loadHooksInDir(dir, hooks);
+
+  // load ee admin hooks if they exist
+  if (process.env.STRAPI_DISABLE_EE !== 'true' && strapi.EE) {
+    await loadHooksInDir(`${dir}/../ee/${hooksDir}`, hooks);
+  }
+};
+
+const loadLocalPluginsHooks = async (appPath, hooks) => {
+  const pluginsDir = path.resolve(appPath, 'plugins');
+  if (!fs.existsSync(pluginsDir)) return;
+
+  const pluginsNames = await fs.readdir(pluginsDir);
+
+  for (let pluginName of pluginsNames) {
+    // ignore files
+    const stat = await fs.stat(path.resolve(pluginsDir, pluginName));
+    if (!stat.isDirectory()) continue;
+
+    const dir = path.resolve(pluginsDir, pluginName, 'hooks');
+    await loadHooksInDir(dir, hooks);
+  }
+};
+
+const loadHookDependencies = async (installedHooks, hooks) => {
+  for (let hook of installedHooks) {
+    const hookDir = path.dirname(require.resolve(`strapi-hook-${hook}`));
+
+    const files = await glob('*(index|defaults).*(js|json)', {
+      cwd: hookDir,
+      absolute: true,
+    });
+
+    mountHooks(hook, files, hooks);
+  }
+};
+
+const mountHooks = (name, files, hooks) => {
+  files.forEach(file => {
+    hooks[name] = hooks[name] || { loaded: false };
+
+    let dependencies = [];
+    try {
+      dependencies = _.get(require(`strapi-hook-${name}/package.json`), 'strapi.dependencies', []);
+    } catch (err) {
+      // Silent
+    }
+
+    if (_.endsWith(file, 'index.js') && !hooks[name].load) {
+      Object.defineProperty(hooks[name], 'load', {
+        configurable: false,
+        enumerable: true,
+        get: () => require(file)(strapi),
+      });
+      hooks[name].dependencies = dependencies;
+      return;
+    }
+
+    if (_.endsWith(file, 'defaults.json')) {
+      hooks[name].defaults = require(file);
+      return;
+    }
+  });
+};

package/lib/core/load-middlewares.js

@@ -0,0 +1,130 @@
+'use strict';
+
+// Dependencies.
+const path = require('path');
+const fs = require('fs-extra');
+const _ = require('lodash');
+const glob = require('../load/glob');
+const findPackagePath = require('../load/package-path');
+
+/**
+ * Load middlewares
+ */
+module.exports = async function(strapi) {
+  const { installedMiddlewares, installedPlugins, appPath } = strapi.config;
+
+  let middlewares = {};
+
+  const loaders = createLoaders(strapi);
+
+  await loaders.loadMiddlewareDependencies(installedMiddlewares, middlewares);
+  // internal middlewares
+  await loaders.loadInternalMiddlewares(middlewares);
+  // local middleware
+  await loaders.loadLocalMiddlewares(appPath, middlewares);
+  // plugins middlewares
+  await loaders.loadPluginsMiddlewares(installedPlugins, middlewares);
+  // local plugin middlewares
+  await loaders.loadLocalPluginsMiddlewares(appPath, middlewares);
+  // load admin middlwares
+  await loaders.loadAdminMiddlewares(middlewares);
+
+  return middlewares;
+};
+
+/**
+ * Build loader functions
+ * @param {*} strapi - strapi instance
+ */
+const createLoaders = strapi => {
+  const loadMiddlewaresInDir = async (dir, middlewares) => {
+    const files = await glob('*/*(index|defaults).*(js|json)', {
+      cwd: dir,
+    });
+
+    files.forEach(f => {
+      const name = f.split('/')[0];
+      mountMiddleware(name, [path.resolve(dir, f)], middlewares);
+    });
+  };
+
+  const loadInternalMiddlewares = middlewares =>
+    loadMiddlewaresInDir(path.resolve(__dirname, '..', 'middlewares'), middlewares);
+
+  const loadLocalMiddlewares = (appPath, middlewares) =>
+    loadMiddlewaresInDir(path.resolve(appPath, 'middlewares'), middlewares);
+
+  const loadPluginsMiddlewares = async (plugins, middlewares) => {
+    for (let pluginName of plugins) {
+      const dir = path.resolve(findPackagePath(`strapi-plugin-${pluginName}`), 'middlewares');
+      await loadMiddlewaresInDir(dir, middlewares);
+    }
+  };
+
+  const loadLocalPluginsMiddlewares = async (appPath, middlewares) => {
+    const pluginsDir = path.resolve(appPath, 'plugins');
+    if (!fs.existsSync(pluginsDir)) return;
+
+    const pluginsNames = await fs.readdir(pluginsDir);
+
+    for (let pluginFolder of pluginsNames) {
+      // ignore files
+      const stat = await fs.stat(path.resolve(pluginsDir, pluginFolder));
+      if (!stat.isDirectory()) continue;
+
+      const dir = path.resolve(pluginsDir, pluginFolder, 'middlewares');
+      await loadMiddlewaresInDir(dir, middlewares);
+    }
+  };
+
+  const loadAdminMiddlewares = async middlewares => {
+    const middlewaresDir = 'middlewares';
+    const dir = path.resolve(findPackagePath(`strapi-admin`), middlewaresDir);
+    await loadMiddlewaresInDir(dir, middlewares);
+
+    // load ee admin middlewares if they exist
+    if (process.env.STRAPI_DISABLE_EE !== 'true' && strapi.EE) {
+      await loadMiddlewaresInDir(`${dir}/../ee/${middlewaresDir}`, middlewares);
+    }
+  };
+
+  const loadMiddlewareDependencies = async (packages, middlewares) => {
+    for (let packageName of packages) {
+      const baseDir = path.dirname(require.resolve(`strapi-middleware-${packageName}`));
+      const files = await glob('*(index|defaults).*(js|json)', {
+        cwd: baseDir,
+        absolute: true,
+      });
+
+      mountMiddleware(packageName, files, middlewares);
+    }
+  };
+
+  const mountMiddleware = (name, files, middlewares) => {
+    files.forEach(file => {
+      middlewares[name] = middlewares[name] || { loaded: false };
+
+      if (_.endsWith(file, 'index.js') && !middlewares[name].load) {
+        return Object.defineProperty(middlewares[name], 'load', {
+          configurable: false,
+          enumerable: true,
+          get: () => require(file)(strapi),
+        });
+      }
+
+      if (_.endsWith(file, 'defaults.json')) {
+        middlewares[name].defaults = require(file);
+        return;
+      }
+    });
+  };
+
+  return {
+    loadInternalMiddlewares,
+    loadLocalMiddlewares,
+    loadPluginsMiddlewares,
+    loadLocalPluginsMiddlewares,
+    loadMiddlewareDependencies,
+    loadAdminMiddlewares,
+  };
+};

package/lib/core/load-modules.js

@@ -0,0 +1,61 @@
+/**
+ * Load Modules is the root module loader.
+ * This is where all the strapi enviornment is laoded
+ * - APIs
+ * - Plugins
+ * - Hooks
+ * - Middlewres
+ * - Components
+ * - ContentTypes
+ */
+'use strict';
+
+const _ = require('lodash');
+
+const loadApis = require('./load-apis');
+const loadAdmin = require('./load-admin');
+const loadPlugins = require('./load-plugins');
+const loadMiddlewares = require('./load-middlewares');
+const loadExtensions = require('./load-extensions');
+const loadHooks = require('./load-hooks');
+const loadComponents = require('./load-components');
+
+module.exports = async strapi => {
+  const [api, admin, plugins, middlewares, hook, extensions, components] = await Promise.all([
+    loadApis(strapi),
+    loadAdmin(strapi),
+    loadPlugins(strapi),
+    loadMiddlewares(strapi),
+    loadHooks(strapi.config),
+    loadExtensions(strapi.config),
+    loadComponents(strapi),
+  ]);
+
+  // TODO: move this into the appropriate loaders
+
+  /**
+   * Handle plugin extensions
+   */
+  // merge extensions config folders
+  _.mergeWith(plugins, extensions.merges, (objValue, srcValue, key) => {
+    // concat routes
+    if (_.isArray(srcValue) && _.isArray(objValue) && key === 'routes') {
+      return srcValue.concat(objValue);
+    }
+  });
+
+  // overwrite plugins with extensions overwrites
+  extensions.overwrites.forEach(({ path, mod }) => {
+    _.assign(_.get(plugins, path), mod);
+  });
+
+  return {
+    api,
+    admin,
+    plugins,
+    middlewares,
+    hook,
+    extensions,
+    components,
+  };
+};

package/lib/core/load-plugins.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const { join } = require('path');
+const { existsSync } = require('fs-extra');
+const _ = require('lodash');
+const findPackagePath = require('../load/package-path');
+const loadFiles = require('../load/load-files');
+const loadConfig = require('../load/load-config-files');
+
+module.exports = async ({ dir, config }) => {
+  const localPlugins = await loadLocalPlugins({ dir, config });
+  const plugins = await loadPlugins({
+    installedPlugins: config.installedPlugins,
+    config,
+  });
+
+  const pluginsIntersection = _.intersection(Object.keys(localPlugins), Object.keys(plugins));
+
+  if (pluginsIntersection.length > 0) {
+    throw new Error(
+      `You have some local plugins with the same name as npm installed plugins:\n${pluginsIntersection
+        .map(p => `- ${p}`)
+        .join('\n')}`
+    );
+  }
+
+  // check for conflicts
+  return _.merge(plugins, localPlugins);
+};
+
+const loadLocalPlugins = async ({ dir, config }) => {
+  const pluginsDir = join(dir, 'plugins');
+
+  if (!existsSync(pluginsDir)) return {};
+
+  const [files, configs] = await Promise.all([
+    loadFiles(pluginsDir, '{*/!(config)/*.*(js|json),*/package.json}'),
+    loadConfig(pluginsDir, '*/config/**/*.+(js|json)'),
+  ]);
+  const userConfigs = Object.keys(files).reduce((acc, plugin) => {
+    acc[plugin] = { config: config.get(['plugins', plugin], {}) };
+    return acc;
+  }, {});
+  return _.merge(files, configs, userConfigs);
+};
+
+const loadPlugins = async ({ installedPlugins, config }) => {
+  let plugins = {};
+
+  for (let plugin of installedPlugins) {
+    const pluginPath = findPackagePath(`strapi-plugin-${plugin}`);
+
+    const files = await loadFiles(
+      pluginPath,
+      '{!(config|node_modules|tests)/*.*(js|json),package.json}'
+    );
+
+    const { config: pluginConfig } = await loadConfig(pluginPath);
+
+    const userConfig = config.get(['plugins', plugin], {});
+
+    const mergedConfig = _.merge(pluginConfig, userConfig);
+
+    _.set(plugins, plugin, _.assign({}, files, { config: mergedConfig }));
+  }
+
+  return plugins;
+};

package/lib/core/load-policies.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const assert = require('assert');
+const path = require('path');
+const _ = require('lodash');
+const fse = require('fs-extra');
+
+module.exports = dir => {
+  if (!fse.existsSync(dir)) return {};
+
+  const root = {};
+  const paths = fse.readdirSync(dir, { withFileTypes: true }).filter(fd => fd.isFile());
+
+  for (let fd of paths) {
+    const { name } = fd;
+    const fullPath = dir + path.sep + name;
+
+    const ext = path.extname(name);
+    const key = path.basename(name, ext);
+    root[_.toLower(key)] = loadPolicy(fullPath);
+  }
+
+  return root;
+};
+
+const loadPolicy = file => {
+  try {
+    const policy = require(file);
+
+    assert(typeof policy === 'function', 'Policy must be a function.');
+
+    return policy;
+  } catch (error) {
+    throw `Could not load policy ${file}: ${error.message}`;
+  }
+};

package/lib/core/walk.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const assert = require('assert');
+const path = require('path');
+const fse = require('fs-extra');
+
+module.exports = function walk(dir, { loader } = {}) {
+  assert(typeof loader === 'function', 'opts.loader must be a function');
+
+  const root = {};
+  const paths = fse.readdirSync(dir, { withFileTypes: true });
+
+  for (let fd of paths) {
+    const { name } = fd;
+    const fullPath = dir + path.sep + name;
+
+    if (fd.isDirectory()) {
+      root[name] = walk(fullPath, { loader });
+    } else {
+      const ext = path.extname(name);
+      const key = path.basename(name, ext);
+      root[key] = loader(fullPath);
+    }
+  }
+
+  return root;
+};

package/lib/core-api/controller.js

@@ -0,0 +1,158 @@
+'use strict';
+
+const _ = require('lodash');
+const { parseMultipartData, sanitizeEntity } = require('@akemona-org/strapi-utils');
+
+const createSanitizeFn = (model) => (data) => {
+  return sanitizeEntity(data, { model: strapi.getModel(model.uid) });
+};
+
+/**
+ * default bookshelf controller
+ *
+ */
+module.exports = ({ service, model }) => {
+  if (model.kind === 'singleType') {
+    return createSingleTypeController({ model, service });
+  }
+
+  return createCollectionTypeController({ model, service });
+};
+
+/**
+ * Returns a single type controller to handle default core-api actions
+ */
+const createSingleTypeController = ({ model, service }) => {
+  const sanitize = createSanitizeFn(model);
+
+  return {
+    /**
+     * Retrieve single type content
+     *
+     * @return {Object|Array}
+     */
+    async find(ctx) {
+      const { query } = ctx;
+      const entity = await service.find(query);
+      return sanitize(entity);
+    },
+
+    /**
+     * create or update single type content.
+     *
+     * @return {Object}
+     */
+    async update(ctx) {
+      const { body, query } = ctx.request;
+
+      let entity;
+      if (ctx.is('multipart')) {
+        const { data, files } = parseMultipartData(ctx);
+        entity = await service.createOrUpdate(data, { files, query });
+      } else {
+        entity = await service.createOrUpdate(body, { query });
+      }
+
+      return sanitize(entity);
+    },
+
+    async delete(ctx) {
+      const entity = await service.delete(ctx.query);
+      return sanitize(entity);
+    },
+  };
+};
+
+/**
+ *
+ * Returns a collection type controller to handle default core-api actions
+ */
+const createCollectionTypeController = ({ model, service }) => {
+  const sanitize = createSanitizeFn(model);
+
+  return {
+    /**
+     * Retrieve records.
+     *
+     * @return {Object|Array}
+     */
+    async find(ctx) {
+      let entities;
+      if (_.has(ctx.query, '_q')) {
+        entities = await service.search(ctx.query);
+      } else {
+        entities = await service.find(ctx.query);
+      }
+
+      return sanitize(entities);
+    },
+
+    /**
+     * Retrieve a record.
+     *
+     * @return {Object}
+     */
+    async findOne(ctx) {
+      const { query, params } = ctx;
+      const entity = await service.findOne({ ...query, id: params.id });
+
+      return sanitize(entity);
+    },
+
+    /**
+     * Count records.
+     *
+     * @return {Number}
+     */
+    count(ctx) {
+      if (_.has(ctx.query, '_q')) {
+        return service.countSearch(ctx.query);
+      }
+      return service.count(ctx.query);
+    },
+
+    /**
+     * Create a record.
+     *
+     * @return {Object}
+     */
+    async create(ctx) {
+      let entity;
+      if (ctx.is('multipart')) {
+        const { data, files } = parseMultipartData(ctx);
+        entity = await service.create(data, { files });
+      } else {
+        entity = await service.create(ctx.request.body);
+      }
+
+      return sanitize(entity);
+    },
+
+    /**
+     * Update a record.
+     *
+     * @return {Object}
+     */
+    async update(ctx) {
+      let entity;
+      if (ctx.is('multipart')) {
+        const { data, files } = parseMultipartData(ctx);
+        entity = await service.update({ id: ctx.params.id }, data, { files });
+      } else {
+        entity = await service.update({ id: ctx.params.id }, ctx.request.body);
+      }
+
+      return sanitize(entity);
+    },
+
+    /**
+     * Destroy a record.
+     *
+     * @return {Object}
+     */
+    async delete(ctx) {
+      const entity = await service.delete({ id: ctx.params.id });
+      return sanitize(entity);
+    },
+  };
+};

package/lib/core-api/index.js

@@ -0,0 +1,33 @@
+/**
+ * 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
+ */
+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,
+};