@akemona-org/strapi 3.7.0

package/lib/core/app-configuration/config-loader.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const { templateConfiguration, env } = require('@akemona-org/strapi-utils');
+
+module.exports = (dir) => {
+  if (!fs.existsSync(dir)) return {};
+
+  return fs
+    .readdirSync(dir, { withFileTypes: true })
+    .filter((file) => file.isFile())
+    .reduce((acc, file) => {
+      const key = path.basename(file.name, path.extname(file.name));
+
+      acc[key] = loadFile(path.resolve(dir, file.name));
+
+      return acc;
+    }, {});
+};
+
+const loadFile = (file) => {
+  const ext = path.extname(file);
+
+  switch (ext) {
+    case '.js':
+      return loadJsFile(file);
+    case '.json':
+      return loadJSONFile(file);
+    default:
+      return {};
+  }
+};
+
+const loadJsFile = (file) => {
+  try {
+    const jsModule = require(file);
+
+    // call if function
+    if (typeof jsModule === 'function') {
+      return jsModule({ env });
+    }
+
+    return jsModule;
+  } catch (error) {
+    throw new Error(`Could not load js config file ${file}: ${error.message}`);
+  }
+};
+
+const loadJSONFile = (file) => {
+  try {
+    return templateConfiguration(JSON.parse(fs.readFileSync(file)));
+  } catch (error) {
+    throw new Error(`Could not load json config file ${file}: ${error.message}`);
+  }
+};

package/lib/core/app-configuration/config-provider.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const assert = require('assert');
+const _ = require('lodash');
+
+module.exports = (initialConfig = {}) => {
+  assert(
+    typeof initialConfig === 'object' && initialConfig !== null,
+    'Initial config must be an object'
+  );
+
+  const _config = _.cloneDeep(initialConfig);
+
+  return Object.assign(_config, {
+    get(path, defaultValue) {
+      return _.get(_config, path, defaultValue);
+    },
+
+    set(path, val) {
+      _.set(_config, path, val);
+      return this;
+    },
+
+    has(path) {
+      return _.has(_config, path);
+    },
+  });
+};

package/lib/core/app-configuration/index.js

@@ -0,0 +1,99 @@
+'use strict';
+
+const os = require('os');
+const path = require('path');
+const _ = require('lodash');
+const dotenv = require('dotenv');
+
+dotenv.config({ path: process.env.ENV_PATH });
+
+process.env.NODE_ENV = process.env.NODE_ENV || 'development';
+
+const getPrefixedDeps = require('../../utils/get-prefixed-dependencies');
+const loadPolicies = require('../load-policies');
+const loadFunctions = require('../load-functions');
+const loadConfigDir = require('./config-loader');
+const createConfigProvider = require('./config-provider');
+
+const { version: strapiVersion } = require(path.join(__dirname, '../../../package.json'));
+
+const CONFIG_PATHS = {
+  admin: 'admin',
+  api: 'api',
+  config: 'config',
+  controllers: 'controllers',
+  models: 'models',
+  plugins: 'plugins',
+  policies: 'policies',
+  tmp: '.tmp',
+  services: 'services',
+  static: 'public',
+  validators: 'validators',
+  views: 'views',
+};
+
+const defaultConfig = {
+  server: {
+    host: process.env.HOST || os.hostname() || 'localhost',
+    port: process.env.PORT || 1337,
+    proxy: false,
+    cron: { enabled: false },
+    admin: { autoOpen: false },
+  },
+  admin: {},
+  middleware: {
+    timeout: 1000,
+    load: {
+      before: ['responseTime', 'logger', 'cors', 'responses', 'gzip'],
+      order: [],
+      after: ['parser', 'router'],
+    },
+    settings: {},
+  },
+  hook: {
+    timeout: 1000,
+    load: { before: [], order: [], after: [] },
+    settings: {},
+  },
+  routes: {},
+  functions: {},
+  policies: {},
+};
+
+module.exports = (dir, initialConfig = {}) => {
+  const { autoReload = false, serveAdminPanel = true } = initialConfig;
+
+  const pkgJSON = require(path.resolve(dir, 'package.json'));
+
+  const configDir = path.resolve(dir || process.cwd(), 'config');
+
+  const rootConfig = {
+    launchedAt: Date.now(),
+    appPath: dir,
+    paths: CONFIG_PATHS,
+    serveAdminPanel,
+    autoReload,
+    environment: process.env.NODE_ENV,
+    uuid: _.get(pkgJSON, 'strapi.uuid'),
+    packageJsonStrapi: _.omit(_.get(pkgJSON, 'strapi', {}), 'uuid'),
+    info: {
+      ...pkgJSON,
+      strapi: strapiVersion,
+    },
+    installedPlugins: getPrefixedDeps('strapi-plugin', pkgJSON),
+    installedMiddlewares: getPrefixedDeps('strapi-middleware', pkgJSON),
+    installedHooks: getPrefixedDeps('strapi-hook', pkgJSON),
+    installedProviders: getPrefixedDeps('strapi-provider', pkgJSON),
+  };
+
+  const baseConfig = {
+    ...loadConfigDir(configDir),
+    policies: loadPolicies(path.resolve(configDir, 'policies')),
+    functions: loadFunctions(path.resolve(configDir, 'functions')),
+  };
+
+  const envDir = path.resolve(configDir, 'env', process.env.NODE_ENV);
+  const envConfig = loadConfigDir(envDir);
+
+  return createConfigProvider(_.merge(rootConfig, defaultConfig, baseConfig, envConfig));
+};

package/lib/core/bootstrap.js

@@ -0,0 +1,166 @@
+'use strict';
+
+const _ = require('lodash');
+const { getConfigUrls, contentTypes: contentTypesUtils } = require('@akemona-org/strapi-utils');
+
+const { createCoreApi } = require('../core-api');
+
+module.exports = function (strapi) {
+  // Set connections.
+  strapi.connections = {};
+
+  const defaultConnection = strapi.config.get('database.defaultConnection');
+
+  // Set current connections.
+  strapi.config.connections = strapi.config.get('database.connections', {});
+
+  strapi.contentTypes = {};
+
+  // Set models.
+  strapi.models = Object.keys(strapi.api || []).reduce((acc, apiName) => {
+    const api = strapi.api[apiName];
+
+    for (let modelName in api.models) {
+      let model = strapi.api[apiName].models[modelName];
+
+      // mutate model
+      contentTypesUtils.createContentType(model, { modelName, defaultConnection }, { apiName });
+
+      strapi.contentTypes[model.uid] = model;
+
+      const { service, controller } = createCoreApi({ model, api, strapi });
+
+      _.set(strapi.api[apiName], ['services', modelName], service);
+      _.set(strapi.api[apiName], ['controllers', modelName], controller);
+
+      acc[modelName] = model;
+    }
+    return acc;
+  }, {});
+
+  // Set components
+  Object.keys(strapi.components).forEach((componentName) => {
+    const component = strapi.components[componentName];
+    component.connection = component.connection || defaultConnection;
+  });
+
+  // Set controllers.
+  strapi.controllers = Object.keys(strapi.api || []).reduce((acc, key) => {
+    for (let index in strapi.api[key].controllers) {
+      let controller = strapi.api[key].controllers[index];
+      controller.identity = controller.identity || _.upperFirst(index);
+      acc[index] = controller;
+    }
+
+    return acc;
+  }, {});
+
+  // Set services.
+  strapi.services = Object.keys(strapi.api || []).reduce((acc, key) => {
+    for (let index in strapi.api[key].services) {
+      acc[index] = strapi.api[key].services[index];
+    }
+
+    return acc;
+  }, {});
+
+  // Set routes.
+  strapi.config.routes = Object.keys(strapi.api || []).reduce((acc, key) => {
+    return acc.concat(_.get(strapi.api[key], 'config.routes') || {});
+  }, []);
+
+  // Init admin controllers.
+  Object.keys(strapi.admin.controllers || []).forEach((key) => {
+    if (!strapi.admin.controllers[key].identity) {
+      strapi.admin.controllers[key].identity = key;
+    }
+  });
+
+  // Init admin models.
+  Object.keys(strapi.admin.models || []).forEach((modelName) => {
+    let model = strapi.admin.models[modelName];
+
+    // mutate model
+    contentTypesUtils.createContentType(model, { modelName, defaultConnection });
+
+    strapi.contentTypes[model.uid] = model;
+  });
+
+  Object.keys(strapi.plugins).forEach((pluginName) => {
+    let plugin = strapi.plugins[pluginName];
+    Object.assign(plugin, {
+      controllers: plugin.controllers || [],
+      services: plugin.services || [],
+      models: plugin.models || [],
+    });
+
+    Object.keys(plugin.controllers).forEach((key) => {
+      let controller = plugin.controllers[key];
+
+      Object.assign(controller, {
+        identity: controller.identity || key,
+      });
+    });
+
+    Object.keys(plugin.models || []).forEach((modelName) => {
+      let model = plugin.models[modelName];
+
+      // mutate model
+      contentTypesUtils.createContentType(model, { modelName, defaultConnection }, { pluginName });
+
+      strapi.contentTypes[model.uid] = model;
+    });
+  });
+
+  // Preset config in alphabetical order.
+  strapi.config.middleware.settings = Object.keys(strapi.middleware).reduce((acc, current) => {
+    // Try to find the settings in the current environment, then in the main configurations.
+    const currentSettings = _.merge(
+      _.cloneDeep(_.get(strapi.middleware[current], ['defaults', current], {})),
+      strapi.config.get(['middleware', 'settings', current], {})
+    );
+
+    acc[current] = !_.isObject(currentSettings) ? {} : currentSettings;
+
+    // Ensure that enabled key exist by forcing to false.
+    _.defaults(acc[current], { enabled: false });
+
+    return acc;
+  }, {});
+
+  strapi.config.hook.settings = Object.keys(strapi.hook).reduce((acc, current) => {
+    // Try to find the settings in the current environment, then in the main configurations.
+    const currentSettings = _.merge(
+      _.cloneDeep(_.get(strapi.hook[current], ['defaults', current], {})),
+      strapi.config.get(['hook', 'settings', current], {})
+    );
+
+    acc[current] = !_.isObject(currentSettings) ? {} : currentSettings;
+
+    // Ensure that enabled key exist by forcing to false.
+    _.defaults(acc[current], { enabled: false });
+
+    return acc;
+  }, {});
+
+  // default settings
+  strapi.config.port = strapi.config.get('server.port') || strapi.config.port;
+  strapi.config.host = strapi.config.get('server.host') || strapi.config.host;
+
+  const { serverUrl, adminUrl, adminPath } = getConfigUrls(strapi.config.get('server'));
+
+  strapi.config.server = strapi.config.server || {};
+  strapi.config.server.url = serverUrl;
+  strapi.config.admin.url = adminUrl;
+  strapi.config.admin.path = adminPath;
+
+  // check if we should serve admin panel
+  const shouldServeAdmin = strapi.config.get(
+    'server.admin.serveAdminPanel',
+    strapi.config.serveAdminPanel
+  );
+
+  if (!shouldServeAdmin) {
+    strapi.config.serveAdminPanel = false;
+  }
+};

package/lib/core/fs.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const path = require('path');
+const fse = require('fs-extra');
+
+/**
+ * create strapi fs layer
+ */
+module.exports = strapi => {
+  function normalizePath(optPath) {
+    const filePath = Array.isArray(optPath) ? optPath.join('/') : optPath;
+
+    const normalizedPath = path.normalize(filePath).replace(/^(\/?\.\.?)+/, '');
+
+    return path.join(strapi.dir, normalizedPath);
+  }
+
+  const strapiFS = {
+    /**
+     * Writes a file in a strapi app
+     * @param {Array|string} optPath - file path
+     * @param {string} data - content
+     */
+    writeAppFile(optPath, data) {
+      const writePath = normalizePath(optPath);
+      return fse
+        .ensureFile(writePath)
+        .then(() => fse.writeFile(writePath, data));
+    },
+
+    /**
+     * Writes a file in a plugin extensions folder
+     * @param {string} plugin - plugin name
+     * @param {Array|string} optPath - path to file
+     * @param {string} data - content
+     */
+    writePluginFile(plugin, optPath, data) {
+      const newPath = ['extensions', plugin].concat(optPath).join('/');
+      return strapiFS.writeAppFile(newPath, data);
+    },
+
+    /**
+     * Removes a file in strapi app
+     */
+    removeAppFile(optPath) {
+      const removePath = normalizePath(optPath);
+      return fse.remove(removePath);
+    },
+  };
+
+  return strapiFS;
+};

package/lib/core/index.js

@@ -0,0 +1,21 @@
+'use strict';
+
+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 bootstrap = require('./bootstrap');
+const loadComponents = require('./load-components');
+
+module.exports = {
+  loadApis,
+  loadAdmin,
+  loadPlugins,
+  loadMiddlewares,
+  loadHooks,
+  loadExtensions,
+  loadComponents,
+  bootstrap,
+};

package/lib/core/load-admin.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const _ = require('lodash');
+
+const findPackagePath = require('../load/package-path');
+const loadFiles = require('../load/load-files');
+const loadConfig = require('../load/load-config-files');
+
+const mergeRoutes = (a, b, key) =>
+  _.isArray(a) && _.isArray(b) && key === 'routes' ? a.concat(b) : undefined;
+
+module.exports = async strapi => {
+  const adminPath = findPackagePath('strapi-admin');
+  const [files, config] = await Promise.all([
+    loadFiles(adminPath, '!(config|node_modules|tests|ee|scripts)/*.*(js|json)'),
+    loadConfig(adminPath),
+  ]);
+
+  // set admin config in strapi.config.server.admin
+  const userAdminConfig = strapi.config.get('server.admin');
+  strapi.config.set('server.admin', _.merge(config.config, userAdminConfig));
+
+  // load ee files if they exist
+  let eeFiles = {};
+  let eeConfig = {};
+
+  if (process.env.STRAPI_DISABLE_EE !== 'true' && strapi.EE) {
+    const eeAdminPath = `${adminPath}/ee`;
+    [eeFiles, eeConfig] = await Promise.all([
+      loadFiles(eeAdminPath, '!(config|tests|test)/*.*(js|json)'),
+      loadConfig(eeAdminPath),
+    ]);
+  }
+
+  return _.mergeWith({}, files, eeFiles, config, eeConfig, mergeRoutes);
+};

package/lib/core/load-apis.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const { join } = require('path');
+const { existsSync } = require('fs-extra');
+const _ = require('lodash');
+const loadFiles = require('../load/load-files');
+const loadConfig = require('../load/load-config-files');
+
+module.exports = async ({ dir }) => {
+  const apiDir = join(dir, 'api');
+
+  if (!existsSync(apiDir)) {
+    throw new Error(
+      `Missing api folder. Please create one in your app root directory`
+    );
+  }
+
+  const apis = await loadFiles(apiDir, '*/!(config)/**/*.*(js|json)');
+  const apiConfigs = await loadConfig(apiDir, '*/config/**/*.*(js|json)');
+
+  return _.merge(apis, apiConfigs);
+};

package/lib/core/load-components.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const { join } = require('path');
+const _ = require('lodash');
+const { exists } = require('fs-extra');
+const loadFiles = require('../load/load-files');
+
+module.exports = async strapi => {
+  const componentsDir = join(strapi.dir, 'components');
+
+  if (!(await exists(componentsDir))) {
+    return {};
+  }
+
+  const map = await loadFiles(componentsDir, '*/*.*(js|json)');
+
+  return Object.keys(map).reduce((acc, category) => {
+    Object.keys(map[category]).forEach(key => {
+      const schema = map[category][key];
+
+      const filePath = join(componentsDir, category, schema.__filename__);
+
+      if (!schema.collectionName) {
+        return strapi.stopWithError(
+          `Component ${key} is missing a "collectionName" property.\nVerify file ${filePath}.`
+        );
+      }
+
+      const uid = `${category}.${key}`;
+
+      acc[uid] = Object.assign(schema, {
+        __schema__: _.cloneDeep(schema),
+        uid,
+        category,
+        modelType: 'component',
+        modelName: key,
+        globalId: schema.globalId || _.upperFirst(_.camelCase(`component_${uid}`)),
+      });
+    });
+
+    return acc;
+  }, {});
+};

package/lib/core/load-extensions.js

@@ -0,0 +1,71 @@
+'use strict';
+
+const path = require('path');
+const { existsSync } = require('fs-extra');
+const fse = require('fs-extra');
+const _ = require('lodash');
+const loadConfig = require('../load/load-config-files');
+const loadFiles = require('../load/load-files');
+const glob = require('../load/glob');
+const filePathToPath = require('../load/filepath-to-prop-path');
+
+/**
+ * Loads the extensions folder
+ */
+module.exports = async function({ appPath }) {
+  const extensionsDir = path.resolve(appPath, 'extensions');
+
+  if (!existsSync(extensionsDir)) {
+    throw new Error(`Missing extensions folder. Please create one in your app root directory`);
+  }
+
+  const configs = await loadConfig(extensionsDir, '*/config/**/*.+(js|json)');
+  const controllersAndServices = await loadFiles(
+    extensionsDir,
+    '*/{controllers,services}/*.+(js|json)'
+  );
+
+  const overwrites = await loadOverwrites(extensionsDir);
+
+  return {
+    overwrites,
+    merges: _.merge({}, configs, controllersAndServices),
+  };
+};
+
+const OVERWRITABLE_FOLDERS_GLOB = 'models';
+// returns a list of path and module to overwrite
+const loadOverwrites = async extensionsDir => {
+  const files = await glob(`*/${OVERWRITABLE_FOLDERS_GLOB}/*.*(js|json)`, {
+    cwd: extensionsDir,
+  });
+
+  const overwrites = {};
+  files.forEach(file => {
+    const absolutePath = path.resolve(extensionsDir, file);
+
+    // load module
+    delete require.cache[absolutePath];
+    let mod;
+
+    if (path.extname(absolutePath) === '.json') {
+      mod = fse.readJsonSync(absolutePath);
+    } else {
+      mod = require(absolutePath);
+    }
+
+    const propPath = filePathToPath(file);
+    const strPath = propPath.join('.');
+
+    if (overwrites[strPath]) {
+      _.merge(overwrites[strPath], mod);
+    } else {
+      overwrites[strPath] = mod;
+    }
+  });
+
+  return Object.keys(overwrites).map(strPath => ({
+    path: strPath.split('.'),
+    mod: overwrites[strPath],
+  }));
+};

package/lib/core/load-functions.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const fse = require('fs-extra');
+
+const walk = require('./walk');
+
+const loadFunctions = dir => {
+  if (!fse.existsSync(dir)) return {};
+
+  return walk(dir, { loader: loadFunction });
+};
+
+const loadFunction = file => {
+  try {
+    return require(file);
+  } catch (error) {
+    throw `Could not load function ${file}: ${error.message}`;
+  }
+};
+
+module.exports = loadFunctions;