@strapi/strapi 4.5.0-alpha.0 → 4.5.0-beta.0

package/lib/Strapi.js

@@ -23,6 +23,8 @@ const entityValidator = require('./services/entity-validator');
 const createTelemetry = require('./services/metrics');
 const requestContext = require('./services/request-context');
 const createAuth = require('./services/auth');
+const createCustomFields = require('./services/custom-fields');
+const createContentAPI = require('./services/content-api');
 const createUpdateNotifier = require('./utils/update-notifier');
 const createStartupLogger = require('./utils/startup-logger');
 const { LIFECYCLES } = require('./utils/lifecycles');
@@ -35,12 +37,14 @@ const hooksRegistry = require('./core/registries/hooks');
 const controllersRegistry = require('./core/registries/controllers');
 const modulesRegistry = require('./core/registries/modules');
 const pluginsRegistry = require('./core/registries/plugins');
+const customFieldsRegistry = require('./core/registries/custom-fields');
 const createConfigProvider = require('./core/registries/config');
 const apisRegistry = require('./core/registries/apis');
 const bootstrap = require('./core/bootstrap');
 const loaders = require('./core/loaders');
 const { destroyOnSignal } = require('./utils/signals');
 const sanitizersRegistry = require('./core/registries/sanitizers');
+const convertCustomFieldType = require('./utils/convert-custom-field-type');
 
 // TODO: move somewhere else
 const draftAndPublishSync = require('./migrations/draft-publish');
@@ -75,7 +79,7 @@ class Strapi {
     // Load the app configuration from the dist directory
     const appConfig = loadConfiguration({ appDir: rootDirs.app, distDir: rootDirs.dist }, opts);
 
-    // Instanciate the Strapi container
+    // Instantiate the Strapi container
     this.container = createContainer(this);
 
     // Register every Strapi registry in the container
@@ -88,8 +92,10 @@ class Strapi {
     this.container.register('controllers', controllersRegistry(this));
     this.container.register('modules', modulesRegistry(this));
     this.container.register('plugins', pluginsRegistry(this));
+    this.container.register('custom-fields', customFieldsRegistry(this));
     this.container.register('apis', apisRegistry(this));
     this.container.register('auth', createAuth(this));
+    this.container.register('content-api', createContentAPI(this));
     this.container.register('sanitizers', sanitizersRegistry(this));
 
     // Create a mapping of every useful directory (for the app, dist and static directories)
@@ -99,7 +105,7 @@ class Strapi {
     this.isLoaded = false;
     this.reload = this.reload();
 
-    // Instanciate the Koa app & the HTTP server
+    // Instantiate the Koa app & the HTTP server
     this.server = createServer(this);
 
     // Strapi utils instanciation
@@ -111,6 +117,8 @@ class Strapi {
     this.telemetry = createTelemetry(this);
     this.requestContext = requestContext;
 
+    this.customFields = createCustomFields(this);
+
     createUpdateNotifier(this).notify();
   }
 
@@ -190,6 +198,10 @@ class Strapi {
     return this.container.get('auth');
   }
 
+  get contentAPI() {
+    return this.container.get('content-api');
+  }
+
   get sanitizers() {
     return this.container.get('sanitizers');
   }
@@ -379,6 +391,8 @@ class Strapi {
     this.telemetry.register();
 
     await this.runLifecyclesFunctions(LIFECYCLES.REGISTER);
+    // NOTE: Swap type customField for underlying data type
+    convertCustomFieldType(this);
 
     return this;
   }
@@ -447,6 +461,8 @@ class Strapi {
     await this.server.initMiddlewares();
     await this.server.initRouting();
 
+    await this.contentAPI.permissions.registerActions();
+
     await this.runLifecyclesFunctions(LIFECYCLES.BOOTSTRAP);
 
     this.cron.start();

package/lib/core/registries/custom-fields.js

@@ -0,0 +1,54 @@
+'use strict';
+
+const { has } = require('lodash/fp');
+const validators = require('../../services/entity-validator/validators');
+
+const customFieldsRegistry = (strapi) => {
+  const customFields = {};
+
+  return {
+    getAll() {
+      return customFields;
+    },
+    get(customField) {
+      const registeredCustomField = customFields[customField];
+      if (!registeredCustomField) {
+        throw new Error(`Could not find Custom Field: ${customField}`);
+      }
+
+      return registeredCustomField;
+    },
+    add(customField) {
+      const customFieldList = Array.isArray(customField) ? customField : [customField];
+
+      for (const cf of customFieldList) {
+        if (!has('name', cf) || !has('type', cf)) {
+          throw new Error(`Custom fields require a 'name' and 'type' key`);
+        }
+
+        const { name, plugin, type } = cf;
+        if (!has(type, validators)) {
+          throw new Error(
+            `Custom field type: '${type}' is not a valid Strapi type or it can't be used with a Custom Field`
+          );
+        }
+
+        const isValidObjectKey = /^(?![0-9])[a-zA-Z0-9$_-]+$/g;
+        if (!isValidObjectKey.test(name)) {
+          throw new Error(`Custom field name: '${name}' is not a valid object key`);
+        }
+
+        // When no plugin is specified, or it isn't found in Strapi, default to global
+        const uid = strapi.plugin(plugin) ? `plugin::${plugin}.${name}` : `global::${name}`;
+
+        if (has(uid, customFields)) {
+          throw new Error(`Custom field: '${uid}' has already been registered`);
+        }
+
+        customFields[uid] = cf;
+      }
+    },
+  };
+};
+
+module.exports = customFieldsRegistry;

package/lib/services/auth/index.js

@@ -32,6 +32,7 @@ const createAuthentication = () => {
 
       return this;
     },
+
     async authenticate(ctx, next) {
       const { route } = ctx.state;
 
@@ -47,7 +48,7 @@ const createAuthentication = () => {
       for (const strategy of strategiesToUse) {
         const result = await strategy.authenticate(ctx);
 
-        const { authenticated = false, error = null, credentials } = result || {};
+        const { authenticated = false, credentials, ability = null, error = null } = result || {};
 
         if (error !== null) {
           return ctx.unauthorized(error);
@@ -58,6 +59,7 @@ const createAuthentication = () => {
           ctx.state.auth = {
             strategy,
             credentials,
+            ability,
           };
 
           return next();
@@ -66,6 +68,7 @@ const createAuthentication = () => {
 
       return ctx.unauthorized('Missing or invalid credentials');
     },
+
     async verify(auth, config = {}) {
       if (config === false) {
         return;

package/lib/services/content-api/index.js

@@ -0,0 +1,74 @@
+'use strict';
+
+const _ = require('lodash');
+const instantiatePermissionsUtilities = require('./permissions');
+
+const transformRoutePrefixFor = (pluginName) => (route) => {
+  const prefix = route.config && route.config.prefix;
+  const path = prefix !== undefined ? `${prefix}${route.path}` : `/${pluginName}${route.path}`;
+
+  return {
+    ...route,
+    path,
+  };
+};
+
+/**
+ * Create a content API container that holds logic, tools and utils. (eg: permissions, ...)
+ */
+const createContentAPI = (strapi) => {
+  const getRoutesMap = async () => {
+    const routesMap = {};
+
+    _.forEach(strapi.api, (api, apiName) => {
+      const routes = _.flatMap(api.routes, (route) => {
+        if (_.has(route, 'routes')) {
+          return route.routes;
+        }
+
+        return route;
+      }).filter((route) => route.info.type === 'content-api');
+
+      if (routes.length === 0) {
+        return;
+      }
+
+      const apiPrefix = strapi.config.get('api.rest.prefix');
+      routesMap[`api::${apiName}`] = routes.map((route) => ({
+        ...route,
+        path: `${apiPrefix}${route.path}`,
+      }));
+    });
+
+    _.forEach(strapi.plugins, (plugin, pluginName) => {
+      const transformPrefix = transformRoutePrefixFor(pluginName);
+
+      const routes = _.flatMap(plugin.routes, (route) => {
+        if (_.has(route, 'routes')) {
+          return route.routes.map(transformPrefix);
+        }
+
+        return transformPrefix(route);
+      }).filter((route) => route.info.type === 'content-api');
+
+      if (routes.length === 0) {
+        return;
+      }
+
+      const apiPrefix = strapi.config.get('api.rest.prefix');
+      routesMap[`plugin::${pluginName}`] = routes.map((route) => ({
+        ...route,
+        path: `${apiPrefix}${route.path}`,
+      }));
+    });
+
+    return routesMap;
+  };
+
+  return {
+    permissions: instantiatePermissionsUtilities(strapi),
+    getRoutesMap,
+  };
+};
+
+module.exports = createContentAPI;

package/lib/services/content-api/permissions/engine.js

@@ -0,0 +1,5 @@
+'use strict';
+
+const permissions = require('@strapi/permissions');
+
+module.exports = ({ providers }) => permissions.engine.new({ providers });

package/lib/services/content-api/permissions/index.js

@@ -0,0 +1,148 @@
+'use strict';
+
+const _ = require('lodash');
+const { createActionProvider, createConditionProvider } = require('./providers');
+const createPermissionEngine = require('./engine');
+
+/**
+ * Creates an handler that checks if the permission's action exists in the action registry
+ */
+const createValidatePermissionHandler =
+  (actionProvider) =>
+  ({ permission }) => {
+    const action = actionProvider.get(permission.action);
+
+    // If the action isn't registered into the action provider, then ignore the permission and warn the user
+    if (!action) {
+      strapi.log.debug(
+        `Unknown action "${permission.action}" supplied when registering a new permission`
+      );
+      return false;
+    }
+  };
+
+/**
+ * Create instances of providers and permission engine for the core content-API service.
+ * Also, expose utilities to get informations about available actions and such.
+ *
+ * @param {Strapi.Strapi} strapi
+ */
+module.exports = (strapi) => {
+  // NOTE: Here we define both an action and condition provider,
+  // but at the moment, we're only using the action one.
+  const providers = {
+    action: createActionProvider(),
+    condition: createConditionProvider(),
+  };
+
+  /**
+   * Get a tree representation of the available Content API actions
+   * based on the methods of the Content API controllers.
+   *
+   * @note Only actions bound to a content-API route are returned.
+   *
+   * @return {{ [api: string]: { [controller: string]: string[] }}}
+   */
+  const getActionsMap = () => {
+    const actionMap = {};
+
+    /**
+     * Check if a controller's action is bound to the
+     * content-api by looking at a potential __type__ symbol
+     *
+     * @param {object} action
+     *
+     * @return {boolean}
+     */
+    const isContentApi = (action) => {
+      if (!_.has(action, Symbol.for('__type__'))) {
+        return false;
+      }
+
+      return action[Symbol.for('__type__')].includes('content-api');
+    };
+
+    /**
+     * Register actions from a specific API source into the result tree
+     *
+     * @param {{ [apiName]: { controllers: { [controller]: object } }}} apis The API container
+     * @param {string} source The prefix to use in front the API name
+     *
+     * @return {void}
+     */
+    const registerAPIsActions = (apis, source) => {
+      _.forEach(apis, (api, apiName) => {
+        const controllers = _.reduce(
+          api.controllers,
+          (acc, controller, controllerName) => {
+            const contentApiActions = _.pickBy(controller, isContentApi);
+
+            if (_.isEmpty(contentApiActions)) {
+              return acc;
+            }
+
+            acc[controllerName] = Object.keys(contentApiActions);
+
+            return acc;
+          },
+          {}
+        );
+
+        if (!_.isEmpty(controllers)) {
+          actionMap[`${source}::${apiName}`] = { controllers };
+        }
+      });
+    };
+
+    registerAPIsActions(strapi.api, 'api');
+    registerAPIsActions(strapi.plugins, 'plugin');
+
+    return actionMap;
+  };
+
+  /**
+   * Register all the content-API's controllers actions into the action provider.
+   * This method make use of the {@link getActionsMap} to generate the list of actions to register.
+   *
+   * @return {void}
+   */
+  const registerActions = async () => {
+    const actionsMap = getActionsMap();
+
+    // For each API
+    for (const [api, value] of Object.entries(actionsMap)) {
+      const { controllers } = value;
+
+      // Register controllers methods as actions
+      for (const [controller, actions] of Object.entries(controllers)) {
+        // Register each action individually
+        await Promise.all(
+          actions.map((action) => {
+            const actionUID = `${api}.${controller}.${action}`;
+
+            return providers.action.register(actionUID, {
+              api,
+              controller,
+              action,
+              uid: actionUID,
+            });
+          })
+        );
+      }
+    }
+  };
+
+  // Create an instance of a content-API permission engine
+  // and binds a custom validation handler to it
+  const engine = createPermissionEngine({ providers }).on(
+    'before-format::validate.permission',
+    createValidatePermissionHandler(providers.action)
+  );
+
+  return {
+    engine,
+    providers,
+    registerActions,
+    getActionsMap,
+  };
+};

package/lib/services/content-api/permissions/providers/action.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const { providerFactory } = require('@strapi/utils');
+
+module.exports = (options = {}) => {
+  const provider = providerFactory(options);
+
+  return {
+    ...provider,
+
+    async register(action, payload) {
+      if (strapi.isLoaded) {
+        throw new Error(`You can't register new actions outside the bootstrap function.`);
+      }
+
+      return provider.register(action, payload);
+    },
+  };
+};

package/lib/services/content-api/permissions/providers/condition.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const { providerFactory } = require('@strapi/utils');
+
+module.exports = (options = {}) => {
+  const provider = providerFactory(options);
+
+  return {
+    ...provider,
+
+    async register(condition) {
+      if (strapi.isLoaded) {
+        throw new Error(`You can't register new conditions outside the bootstrap function.`);
+      }
+
+      return provider.register(condition.name, condition);
+    },
+  };
+};

package/lib/services/content-api/permissions/providers/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const createActionProvider = require('./action');
+const createConditionProvider = require('./condition');
+
+module.exports = {
+  createActionProvider,
+  createConditionProvider,
+};

package/lib/services/custom-fields.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const createCustomFields = (strapi) => {
+  return {
+    register(customField) {
+      strapi.container.get('custom-fields').add(customField);
+    },
+  };
+};
+
+module.exports = createCustomFields;

package/lib/services/entity-service/components.js

@@ -47,7 +47,6 @@ const createComponents = async (uid, data) => {
           componentValue.map((value) => createComponent(componentUID, value))
         );
 
-        // TODO: add order
         componentBody[attributeName] = components.map(({ id }) => {
           return {
             id,

package/lib/services/entity-service/index.js

@@ -10,6 +10,7 @@ const {
   sanitize,
 } = require('@strapi/utils');
 const { ValidationError } = require('@strapi/utils').errors;
+const { isAnyToMany } = require('@strapi/utils').relations;
 const { transformParamsToQuery } = require('@strapi/utils').convertQueryParams;
 const uploadFiles = require('../utils/upload-files');
 
@@ -23,6 +24,13 @@ const {
 const { pickSelectionParams } = require('./params');
 const { applyTransforms } = require('./attributes');
 
+const transformLoadParamsToQuery = (uid, field, params = {}, pagination = {}) => {
+  return {
+    ...transformParamsToQuery(uid, { populate: { [field]: params } }).populate[field],
+    ...pagination,
+  };
+};
+
 // TODO: those should be strapi events used by the webhooks not the other way arround
 const { ENTRY_CREATE, ENTRY_UPDATE, ENTRY_DELETE } = webhookUtils.webhookEvents;
 
@@ -245,35 +253,28 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
   },
 
   load(uid, entity, field, params = {}) {
-    const { attributes } = strapi.getModel(uid);
+    if (!_.isString(field)) {
+      throw new Error(`Invalid load. Expected "${field}" to be a string`);
+    }
 
-    const attribute = attributes[field];
+    return db.query(uid).load(entity, field, transformLoadParamsToQuery(uid, field, params));
+  },
 
-    const loadParams = {};
+  loadPages(uid, entity, field, params = {}, pagination = {}) {
+    if (!_.isString(field)) {
+      throw new Error(`Invalid load. Expected "${field}" to be a string`);
+    }
 
-    switch (attribute.type) {
-      case 'relation': {
-        Object.assign(loadParams, transformParamsToQuery(attribute.target, params));
-        break;
-      }
-      case 'component': {
-        Object.assign(loadParams, transformParamsToQuery(attribute.component, params));
-        break;
-      }
-      case 'dynamiczone': {
-        Object.assign(loadParams, transformParamsToQuery(null, params));
-        break;
-      }
-      case 'media': {
-        Object.assign(loadParams, transformParamsToQuery('plugin::upload.file', params));
-        break;
-      }
-      default: {
-        break;
-      }
+    const { attributes } = strapi.getModel(uid);
+    const attribute = attributes[field];
+
+    if (!isAnyToMany(attribute)) {
+      throw new Error(`Invalid load. Expected "${field}" to be an anyToMany relational attribute`);
     }
 
-    return db.query(uid).load(entity, field, loadParams);
+    const query = transformLoadParamsToQuery(uid, field, params, pagination);
+
+    return db.query(uid).loadPages(entity, field, query);
   },
 });
 

package/lib/services/metrics/sender.js

@@ -7,6 +7,7 @@ const isDocker = require('is-docker');
 const fetch = require('node-fetch');
 const ciEnv = require('ci-info');
 const { isUsingTypeScriptSync } = require('@strapi/typescript-utils');
+const { env } = require('@strapi/utils');
 const ee = require('../../utils/ee');
 const machineID = require('../../utils/machine-id');
 const stringifyDeep = require('./stringify-deep');
@@ -54,6 +55,7 @@ module.exports = (strapi) => {
     projectType: isEE ? 'Enterprise' : 'Community',
     useTypescriptOnServer: isUsingTypeScriptSync(serverRootPath),
     useTypescriptOnAdmin: isUsingTypeScriptSync(adminRootPath),
+    isHostedOnStrapiCloud: env('STRAPI_HOSTING', null) === 'strapi.cloud',
   };
 
   addPackageJsonStrapiMetadata(anonymousMetadata, strapi);

package/lib/types/core/attributes/common.d.ts

@@ -29,6 +29,9 @@ export type NonUniqueAttribute = { unique: false };
 export type ConfigurableAttribute = { configurable: true };
 export type NonConfigurableAttribute = { configurable: false };
 
+// custom field
+export type CustomField<T extends string, P extends object = undefined> = { customField: T, options?: P };
+
 // min/max
 export type SetMinMax<T extends MinMaxOption<U>, U = number> = T;
 

package/lib/types/core/strapi/index.d.ts

@@ -5,6 +5,28 @@ import type { StringMap } from './utils';
 import type { GenericController } from '../../../core-api/controller'
 import type { GenericService } from '../../../core-api/service'
 
+// TODO move custom fields types to a separate file
+interface CustomFieldServerOptions {
+  /**
+   * The name of the custom field
+   */
+  name: string;
+
+  /**
+   * The name of the plugin creating the custom field
+   */
+  plugin?: string;
+
+  /**
+   * The existing Strapi data type the custom field uses
+   */
+  type: string;
+}
+
+interface CustomFields {
+  register: (customFields: CustomFieldServerOptions[] | CustomFieldServerOptions) => void;
+}
+
 /**
  * The Strapi interface implemented by the main Strapi class.
  */
@@ -24,6 +46,11 @@ export interface Strapi {
    */
   readonly auth: any;
 
+  /**
+   * Getter for the Strapi content API container
+   */
+  readonly contentAPI: any;
+
   /**
    * Getter for the Strapi sanitizers container
    */
@@ -65,6 +92,13 @@ export interface Strapi {
    */
   contentType(uid: string): any;
 
+  /**
+   * The custom fields registry
+   * 
+   * It returns the custom fields interface
+   */
+  readonly customFields: CustomFields;
+
   /**
    * Getter for the Strapi policies container
    *
@@ -195,7 +229,7 @@ export interface Strapi {
   /**
    * Restart the server and reload all the configuration.
    * It re-runs all the lifecycles phases.
-   * 
+   *
    * @example
    * ``` ts
    * setImmediate(() => strapi.reload());
@@ -223,13 +257,13 @@ export interface Strapi {
   /**
    * Opent he administration panel in a browser if the option is enabled.
    * You can disable it using the admin.autoOpen configuration variable.
-   * 
+   *
    * Note: It only works in development envs.
    */
   openAdmin(options: { isInitialized: boolean }): Promise<void>;
 
   /**
-   * Load the admin panel server logic into the server code and initialize its configuration. 
+   * Load the admin panel server logic into the server code and initialize its configuration.
    */
   loadAdmin(): Promise<void>;
 
@@ -288,7 +322,7 @@ export interface Strapi {
   container: any;
 
   /**
-   * References to all the directories handled by Strapi 
+   * References to all the directories handled by Strapi
    */
   dirs: StrapiDirectories;
 
@@ -323,7 +357,7 @@ export interface Strapi {
   startupLogger: any;
 
   /**
-   * Strapi logger used to send errors, warning or information messages 
+   * Strapi logger used to send errors, warning or information messages
    */
   log: any;
 
@@ -356,7 +390,7 @@ export interface Strapi {
   /**
    * Entity Service instance
    */
-  entityService: any;  
+  entityService: any;
 }
 
 export interface Lifecycles {
@@ -389,4 +423,4 @@ export interface StrapiDirectories {
     middlewares: string;
     config: string;
   };
-}
+}

package/lib/utils/convert-custom-field-type.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const convertCustomFieldType = (strapi) => {
+  const allContentTypeSchemaAttributes = Object.values(strapi.contentTypes).map(
+    (schema) => schema.attributes
+  );
+  const allComponentSchemaAttributes = Object.values(strapi.components).map(
+    (schema) => schema.attributes
+  );
+  const allSchemasAttributes = [...allContentTypeSchemaAttributes, ...allComponentSchemaAttributes];
+
+  for (const schemaAttrbutes of allSchemasAttributes) {
+    for (const attribute of Object.values(schemaAttrbutes)) {
+      if (attribute.type === 'customField') {
+        const customField = strapi.container.get('custom-fields').get(attribute.customField);
+        attribute.type = customField.type;
+      }
+    }
+  }
+};
+
+module.exports = convertCustomFieldType;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/strapi",
-  "version": "4.5.0-alpha.0",
+  "version": "4.5.0-beta.0",
   "description": "An open source headless CMS solution to create and manage your own API. It provides a powerful dashboard and features to make your life easier. Databases supported: MySQL, MariaDB, PostgreSQL, SQLite",
   "keywords": [
     "strapi",
@@ -78,19 +78,20 @@
     "test:unit": "jest --verbose"
   },
   "dependencies": {
-    "@koa/cors": "3.4.1",
+    "@koa/cors": "3.4.2",
     "@koa/router": "10.1.1",
-    "@strapi/admin": "4.5.0-alpha.0",
-    "@strapi/database": "4.5.0-alpha.0",
-    "@strapi/generate-new": "4.5.0-alpha.0",
-    "@strapi/generators": "4.5.0-alpha.0",
-    "@strapi/logger": "4.5.0-alpha.0",
-    "@strapi/plugin-content-manager": "4.5.0-alpha.0",
-    "@strapi/plugin-content-type-builder": "4.5.0-alpha.0",
-    "@strapi/plugin-email": "4.5.0-alpha.0",
-    "@strapi/plugin-upload": "4.5.0-alpha.0",
-    "@strapi/typescript-utils": "4.5.0-alpha.0",
-    "@strapi/utils": "4.5.0-alpha.0",
+    "@strapi/admin": "4.5.0-beta.0",
+    "@strapi/database": "4.5.0-beta.0",
+    "@strapi/generate-new": "4.5.0-beta.0",
+    "@strapi/generators": "4.5.0-beta.0",
+    "@strapi/logger": "4.5.0-beta.0",
+    "@strapi/permissions": "4.5.0-beta.0",
+    "@strapi/plugin-content-manager": "4.5.0-beta.0",
+    "@strapi/plugin-content-type-builder": "4.5.0-beta.0",
+    "@strapi/plugin-email": "4.5.0-beta.0",
+    "@strapi/plugin-upload": "4.5.0-beta.0",
+    "@strapi/typescript-utils": "4.5.0-beta.0",
+    "@strapi/utils": "4.5.0-beta.0",
     "bcryptjs": "2.4.3",
     "boxen": "5.1.2",
     "chalk": "4.1.2",
@@ -139,5 +140,5 @@
     "node": ">=14.19.1 <=18.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "c9a98c4dbcf3c4f2a449f8d96e7cbe4cd9b1e0f5"
+  "gitHead": "ee98b9a9cbb6e0e07e781ff9e87eb170c72e50df"
 }