@opkod-france/strapi-plugin-component-usage 2.0.0

package/dist/server/index.mjs

@@ -0,0 +1,850 @@
+const bootstrap = async ({ strapi }) => {
+  setTimeout(async () => {
+    try {
+      const trackerService = strapi.plugin("component-usage").service("usage-tracker");
+      await trackerService.initializeTracking();
+      await trackerService.recalculateAllUsage();
+      strapi.log.info("[Component Usage] Bootstrap complete");
+    } catch (error) {
+      strapi.log.error("[Component Usage] Bootstrap error:", error);
+    }
+  }, 5e3);
+  const contentTypes2 = Object.keys(strapi.contentTypes).filter(
+    (uid) => {
+      return uid.startsWith("api::") || uid.startsWith("plugin::") && !uid.startsWith("plugin::upload.") && !uid.startsWith("plugin::users-permissions.") && !uid.startsWith("plugin::component-usage.");
+    }
+  );
+  for (const uid of contentTypes2) {
+    strapi.db.lifecycles.subscribe({
+      models: [uid],
+      async afterCreate(event) {
+        const { result } = event;
+        try {
+          const trackerService = strapi.plugin("component-usage").service("usage-tracker");
+          await trackerService.updateUsageForEntry(uid, result);
+        } catch (error) {
+          strapi.log.warn(
+            `[Component Usage] Lifecycle error in afterCreate: ${error.message}`
+          );
+        }
+      }
+    });
+    strapi.db.lifecycles.subscribe({
+      models: [uid],
+      async afterUpdate(event) {
+        const { result } = event;
+        try {
+          const trackerService = strapi.plugin("component-usage").service("usage-tracker");
+          await trackerService.updateUsageForEntry(uid, result);
+        } catch (error) {
+          strapi.log.warn(
+            `[Component Usage] Lifecycle error in afterUpdate: ${error.message}`
+          );
+        }
+      }
+    });
+    strapi.db.lifecycles.subscribe({
+      models: [uid],
+      async afterDelete() {
+        try {
+          const trackerService = strapi.plugin("component-usage").service("usage-tracker");
+          setTimeout(async () => {
+            await trackerService.recalculateAllUsage();
+          }, 1e3);
+        } catch (error) {
+          strapi.log.warn(
+            `[Component Usage] Lifecycle error in afterDelete: ${error.message}`
+          );
+        }
+      }
+    });
+  }
+  strapi.log.info(
+    `[Component Usage] Registered lifecycle hooks for ${contentTypes2.length} content types`
+  );
+};
+const searchInObject = (obj, componentName, path = "") => {
+  const results = [];
+  if (!obj || typeof obj !== "object") {
+    return results;
+  }
+  if (obj.__component === componentName) {
+    results.push(path || "root");
+  }
+  for (const [key, value] of Object.entries(obj)) {
+    const currentPath = path ? `${path}.${key}` : key;
+    if (Array.isArray(value)) {
+      value.forEach((item, index2) => {
+        const arrayPath = `${currentPath}[${index2}]`;
+        results.push(...searchInObject(item, componentName, arrayPath));
+      });
+    } else if (value && typeof value === "object") {
+      results.push(...searchInObject(value, componentName, currentPath));
+    }
+  }
+  return results;
+};
+const getScannableContentTypes = (strapi) => {
+  return Object.keys(strapi.contentTypes).filter((uid) => {
+    return uid.startsWith("api::") || uid.startsWith("plugin::") && !uid.startsWith("plugin::upload.") && !uid.startsWith("plugin::users-permissions.") && !uid.startsWith("plugin::component-usage.");
+  });
+};
+const CONTENT_TYPE_UID = "plugin::component-usage.component-usage-tracker";
+const componentUsage$1 = ({ strapi }) => ({
+  async index(ctx) {
+    try {
+      const data = await strapi.plugin("component-usage").service("component-usage").getAllComponentsWithUsage();
+      ctx.body = { data };
+    } catch (err) {
+      ctx.throw(500, err);
+    }
+  },
+  async indexFast(ctx) {
+    try {
+      const trackers = await strapi.plugin("component-usage").service("usage-tracker").getAllTrackedComponents();
+      const allComponents = await strapi.plugin("component-usage").service("component-usage").getAllComponents();
+      const data = allComponents.map((comp) => {
+        const tracker = trackers.find(
+          (t) => t.componentUid === comp.uid
+        );
+        return {
+          ...comp,
+          usageCount: tracker?.usageCount || 0
+        };
+      });
+      ctx.body = { data };
+    } catch (err) {
+      ctx.throw(500, err);
+    }
+  },
+  async show(ctx) {
+    try {
+      const { uid } = ctx.params;
+      const usage = await strapi.plugin("component-usage").service("usage-tracker").getComponentUsage(uid);
+      ctx.body = { data: usage };
+    } catch (err) {
+      ctx.throw(500, err);
+    }
+  },
+  async getComponents(ctx) {
+    try {
+      const data = await strapi.plugin("component-usage").service("component-usage").getAllComponents();
+      ctx.body = { data };
+    } catch (err) {
+      ctx.throw(500, err);
+    }
+  },
+  async delete(ctx) {
+    try {
+      const { uid } = ctx.params;
+      if (!uid) {
+        return ctx.badRequest("Component UID is required");
+      }
+      const result = await strapi.plugin("component-usage").service("component-usage").deleteComponent(uid);
+      const tracker = await strapi.documents(CONTENT_TYPE_UID).findMany({
+        filters: { componentUid: uid },
+        limit: 1
+      });
+      if (tracker && tracker.length > 0) {
+        await strapi.documents(CONTENT_TYPE_UID).delete({
+          documentId: tracker[0].documentId
+        });
+      }
+      ctx.body = { data: result };
+    } catch (err) {
+      strapi.log.error("Error deleting component:", err);
+      if (err.message.includes("not found")) {
+        return ctx.notFound(err.message);
+      }
+      if (err.message.includes("being used")) {
+        return ctx.badRequest(err.message);
+      }
+      ctx.throw(500, err);
+    }
+  },
+  async clearCache(ctx) {
+    try {
+      const cacheResult = strapi.plugin("component-usage").service("component-usage").clearCache();
+      const trackerService = strapi.plugin("component-usage").service("usage-tracker");
+      await trackerService.recalculateAllUsage();
+      ctx.body = {
+        data: {
+          ...cacheResult,
+          message: "Cache cleared and usage recalculated"
+        }
+      };
+    } catch (err) {
+      ctx.throw(500, err);
+    }
+  },
+  async recalculate(ctx) {
+    try {
+      const trackerService = strapi.plugin("component-usage").service("usage-tracker");
+      await trackerService.recalculateAllUsage();
+      ctx.body = {
+        data: {
+          success: true,
+          message: "Component usage recalculated successfully"
+        }
+      };
+    } catch (err) {
+      ctx.throw(500, err);
+    }
+  },
+  async getRelationships(ctx) {
+    try {
+      const { uid } = ctx.params;
+      const relationshipsService = strapi.plugin("component-usage").service("component-relationships");
+      const data = relationshipsService.getComponentWithRelationships(uid);
+      if (!data) {
+        return ctx.notFound(`Component ${uid} not found`);
+      }
+      ctx.body = { data };
+    } catch (err) {
+      ctx.throw(500, err);
+    }
+  },
+  async getDependencyGraph(ctx) {
+    try {
+      const relationshipsService = strapi.plugin("component-usage").service("component-relationships");
+      const data = relationshipsService.getDependencyGraph();
+      ctx.body = { data };
+    } catch (err) {
+      ctx.throw(500, err);
+    }
+  },
+  async getTotalUsage(ctx) {
+    try {
+      const { uid } = ctx.params;
+      const relationshipsService = strapi.plugin("component-usage").service("component-relationships");
+      const data = await relationshipsService.getTotalUsageCount(uid);
+      ctx.body = { data };
+    } catch (err) {
+      ctx.throw(500, err);
+    }
+  }
+});
+const controllers = {
+  "component-usage": componentUsage$1
+};
+const routes = [
+  {
+    method: "GET",
+    path: "/components",
+    handler: "component-usage.indexFast",
+    config: {
+      policies: [],
+      auth: false
+    }
+  },
+  {
+    method: "GET",
+    path: "/components/full",
+    handler: "component-usage.index",
+    config: {
+      policies: [],
+      auth: false
+    }
+  },
+  {
+    method: "GET",
+    path: "/components/:uid/usage",
+    handler: "component-usage.show",
+    config: {
+      policies: [],
+      auth: false
+    }
+  },
+  {
+    method: "GET",
+    path: "/components-list",
+    handler: "component-usage.getComponents",
+    config: {
+      policies: [],
+      auth: false
+    }
+  },
+  {
+    method: "DELETE",
+    path: "/components/:uid",
+    handler: "component-usage.delete",
+    config: {
+      policies: [],
+      auth: false
+    }
+  },
+  {
+    method: "POST",
+    path: "/cache/clear",
+    handler: "component-usage.clearCache",
+    config: {
+      policies: [],
+      auth: false
+    }
+  },
+  {
+    method: "POST",
+    path: "/recalculate",
+    handler: "component-usage.recalculate",
+    config: {
+      policies: [],
+      auth: false
+    }
+  },
+  {
+    method: "GET",
+    path: "/components/:uid/relationships",
+    handler: "component-usage.getRelationships",
+    config: {
+      policies: [],
+      auth: false
+    }
+  },
+  {
+    method: "GET",
+    path: "/components/:uid/total-usage",
+    handler: "component-usage.getTotalUsage",
+    config: {
+      policies: [],
+      auth: false
+    }
+  },
+  {
+    method: "GET",
+    path: "/dependency-graph",
+    handler: "component-usage.getDependencyGraph",
+    config: {
+      policies: [],
+      auth: false
+    }
+  }
+];
+const cache = {
+  data: /* @__PURE__ */ new Map(),
+  timestamps: /* @__PURE__ */ new Map(),
+  TTL: 5 * 60 * 1e3,
+  // 5 minutes
+  set(key, value) {
+    this.data.set(key, value);
+    this.timestamps.set(key, Date.now());
+  },
+  get(key) {
+    const timestamp = this.timestamps.get(key);
+    if (!timestamp || Date.now() - timestamp > this.TTL) {
+      this.data.delete(key);
+      this.timestamps.delete(key);
+      return null;
+    }
+    return this.data.get(key);
+  },
+  clear() {
+    this.data.clear();
+    this.timestamps.clear();
+  }
+};
+const componentUsage = ({ strapi }) => ({
+  async getAllComponents() {
+    const components = Object.keys(strapi.components).map((uid) => {
+      const component = strapi.components[uid];
+      return {
+        uid,
+        category: component.category,
+        displayName: component.info?.displayName || component.modelName,
+        icon: component.info?.icon,
+        attributes: component.attributes
+      };
+    });
+    return components;
+  },
+  async getComponentUsageCount(componentUid) {
+    const cacheKey = `count:${componentUid}`;
+    const cached = cache.get(cacheKey);
+    if (cached !== null) {
+      return cached;
+    }
+    let totalCount = 0;
+    const contentTypes2 = getScannableContentTypes(strapi);
+    for (const contentTypeUid of contentTypes2) {
+      try {
+        const entries = await strapi.documents(contentTypeUid).findMany({
+          populate: "*",
+          status: "draft"
+        });
+        if (!entries || entries.length === 0) {
+          continue;
+        }
+        for (const entry of entries) {
+          const matches = searchInObject(entry, componentUid);
+          totalCount += matches.length;
+        }
+      } catch (error) {
+        strapi.log.warn(
+          `Could not count usage for ${contentTypeUid}: ${error.message}`
+        );
+      }
+    }
+    cache.set(cacheKey, totalCount);
+    return totalCount;
+  },
+  async getComponentUsage(componentUid) {
+    const cacheKey = `usage:${componentUid}`;
+    const cached = cache.get(cacheKey);
+    if (cached !== null) {
+      return cached;
+    }
+    const contentTypes2 = getScannableContentTypes(strapi);
+    const usageData = [];
+    for (const contentTypeUid of contentTypes2) {
+      try {
+        const entries = await strapi.documents(contentTypeUid).findMany({
+          populate: "*",
+          status: "draft"
+        });
+        if (!entries || entries.length === 0) {
+          continue;
+        }
+        for (const entry of entries) {
+          const matches = searchInObject(entry, componentUid);
+          if (matches.length > 0) {
+            const contentTypeName = contentTypeUid.replace("api::", "").replace("plugin::", "");
+            matches.forEach((fieldPath) => {
+              usageData.push({
+                contentType: contentTypeName,
+                contentTypeUid,
+                entryId: entry.documentId || entry.id?.toString() || "N/A",
+                fieldPath
+              });
+            });
+          }
+        }
+      } catch (error) {
+        strapi.log.warn(
+          `Could not fetch entries for ${contentTypeUid}: ${error.message}`
+        );
+      }
+    }
+    cache.set(cacheKey, usageData);
+    return usageData;
+  },
+  async getAllComponentsWithUsage() {
+    const components = await this.getAllComponents();
+    const componentsWithUsage = await Promise.all(
+      components.map(async (component) => {
+        const usage = await this.getComponentUsage(component.uid);
+        return {
+          ...component,
+          usageCount: usage.length,
+          usage
+        };
+      })
+    );
+    return componentsWithUsage;
+  },
+  async deleteComponent(componentUid) {
+    const fs = require("fs");
+    if (!strapi.components[componentUid]) {
+      throw new Error(`Component ${componentUid} not found`);
+    }
+    const usageCount = await this.getComponentUsageCount(componentUid);
+    if (usageCount > 0) {
+      throw new Error(
+        `Cannot delete component ${componentUid}. It is being used in ${usageCount} place(s).`
+      );
+    }
+    const component = strapi.components[componentUid];
+    const componentPath = component.__filename__;
+    if (!componentPath) {
+      throw new Error(
+        `Could not find file path for component ${componentUid}`
+      );
+    }
+    try {
+      if (fs.existsSync(componentPath)) {
+        fs.unlinkSync(componentPath);
+        strapi.log.info(`Deleted component file: ${componentPath}`);
+      }
+      delete strapi.components[componentUid];
+      cache.clear();
+      return {
+        success: true,
+        message: `Component ${componentUid} deleted successfully`
+      };
+    } catch (error) {
+      strapi.log.error(`Error deleting component file: ${error.message}`);
+      throw new Error(`Failed to delete component file: ${error.message}`);
+    }
+  },
+  clearCache() {
+    cache.clear();
+    return { success: true, message: "Cache cleared" };
+  }
+});
+const usageTracker = ({ strapi }) => ({
+  async initializeTracking() {
+    strapi.log.info("[Component Usage] Initializing component tracking...");
+    const components = Object.keys(strapi.components).map((uid) => {
+      const component = strapi.components[uid];
+      return {
+        uid,
+        category: component.category,
+        displayName: component.info?.displayName || component.modelName
+      };
+    });
+    for (const component of components) {
+      try {
+        const existing = await strapi.documents(CONTENT_TYPE_UID).findMany({
+          filters: { componentUid: component.uid },
+          limit: 1
+        });
+        if (!existing || existing.length === 0) {
+          await strapi.documents(CONTENT_TYPE_UID).create({
+            data: {
+              componentUid: component.uid,
+              componentName: component.displayName,
+              componentCategory: component.category,
+              usageCount: 0,
+              usages: [],
+              lastUpdated: /* @__PURE__ */ new Date()
+            }
+          });
+        }
+      } catch (error) {
+        strapi.log.error(
+          `[Component Usage] Error creating tracker for ${component.uid}: ${error.message}`
+        );
+      }
+    }
+    strapi.log.info("[Component Usage] Component tracking initialized");
+  },
+  async recalculateAllUsage() {
+    strapi.log.info("[Component Usage] Recalculating all component usage...");
+    const components = Object.keys(strapi.components);
+    const contentTypes2 = getScannableContentTypes(strapi);
+    for (const componentUid of components) {
+      const usages = [];
+      for (const contentTypeUid of contentTypes2) {
+        try {
+          const entries = await strapi.documents(contentTypeUid).findMany({
+            populate: "*",
+            status: "draft"
+          });
+          if (!entries || entries.length === 0) {
+            continue;
+          }
+          for (const entry of entries) {
+            const matches = searchInObject(entry, componentUid);
+            if (matches.length > 0) {
+              const contentTypeName = contentTypeUid.replace("api::", "").replace("plugin::", "");
+              matches.forEach((fieldPath) => {
+                usages.push({
+                  contentType: contentTypeName,
+                  contentTypeUid,
+                  entryId: entry.documentId || entry.id?.toString() || "N/A",
+                  fieldPath
+                });
+              });
+            }
+          }
+        } catch (error) {
+          strapi.log.warn(
+            `[Component Usage] Could not scan ${contentTypeUid} for ${componentUid}: ${error.message}`
+          );
+        }
+      }
+      await this.updateComponentUsage(componentUid, usages);
+    }
+    strapi.log.info("[Component Usage] Recalculation complete");
+  },
+  async updateComponentUsage(componentUid, usages = []) {
+    try {
+      const existing = await strapi.documents(CONTENT_TYPE_UID).findMany({
+        filters: { componentUid },
+        limit: 1
+      });
+      if (existing && existing.length > 0) {
+        await strapi.documents(CONTENT_TYPE_UID).update({
+          documentId: existing[0].documentId,
+          data: {
+            usageCount: usages.length,
+            usages,
+            lastUpdated: /* @__PURE__ */ new Date()
+          }
+        });
+      }
+    } catch (error) {
+      strapi.log.error(
+        `[Component Usage] Error updating tracker for ${componentUid}: ${error.message}`
+      );
+    }
+  },
+  async updateUsageForEntry(contentTypeUid, entry) {
+    if (!entry) return;
+    const components = Object.keys(strapi.components);
+    for (const componentUid of components) {
+      const matches = searchInObject(entry, componentUid);
+      if (matches.length > 0) {
+        await this.recalculateComponentUsage(componentUid);
+      }
+    }
+  },
+  async recalculateComponentUsage(componentUid) {
+    const contentTypes2 = getScannableContentTypes(strapi);
+    const usages = [];
+    for (const contentTypeUid of contentTypes2) {
+      try {
+        const entries = await strapi.documents(contentTypeUid).findMany({
+          populate: "*",
+          status: "draft"
+        });
+        if (!entries || entries.length === 0) {
+          continue;
+        }
+        for (const entry of entries) {
+          const matches = searchInObject(entry, componentUid);
+          if (matches.length > 0) {
+            const contentTypeName = contentTypeUid.replace("api::", "").replace("plugin::", "");
+            matches.forEach((fieldPath) => {
+              usages.push({
+                contentType: contentTypeName,
+                contentTypeUid,
+                entryId: entry.documentId || entry.id?.toString() || "N/A",
+                fieldPath
+              });
+            });
+          }
+        }
+      } catch (error) {
+        strapi.log.warn(
+          `[Component Usage] Could not scan ${contentTypeUid}: ${error.message}`
+        );
+      }
+    }
+    await this.updateComponentUsage(componentUid, usages);
+  },
+  async getAllTrackedComponents() {
+    try {
+      const trackers = await strapi.documents(CONTENT_TYPE_UID).findMany({
+        limit: 1e3
+      });
+      return trackers || [];
+    } catch (error) {
+      strapi.log.error(
+        "[Component Usage] Error fetching trackers:",
+        error.message
+      );
+      return [];
+    }
+  },
+  async getComponentUsage(componentUid) {
+    try {
+      const tracker = await strapi.documents(CONTENT_TYPE_UID).findMany({
+        filters: { componentUid },
+        limit: 1
+      });
+      if (tracker && tracker.length > 0) {
+        return tracker[0].usages || [];
+      }
+      return [];
+    } catch (error) {
+      strapi.log.error(
+        `[Component Usage] Error fetching usage for ${componentUid}: ${error.message}`
+      );
+      return [];
+    }
+  }
+});
+const findNestedComponents = (attributes2) => {
+  const nestedComponents = [];
+  if (!attributes2 || typeof attributes2 !== "object") {
+    return nestedComponents;
+  }
+  for (const [attrName, attrConfig] of Object.entries(attributes2)) {
+    if (attrConfig.type === "component" && attrConfig.component) {
+      nestedComponents.push({
+        componentUid: attrConfig.component,
+        attributeName: attrName,
+        repeatable: attrConfig.repeatable || false
+      });
+    }
+    if (attrConfig.type === "dynamiczone" && attrConfig.components) {
+      attrConfig.components.forEach((componentUid) => {
+        nestedComponents.push({
+          componentUid,
+          attributeName: attrName,
+          isDynamicZone: true
+        });
+      });
+    }
+  }
+  return nestedComponents;
+};
+const buildDependencyGraph = (components) => {
+  const graph = {};
+  Object.keys(components).forEach((uid) => {
+    graph[uid] = {
+      uid,
+      displayName: components[uid].info?.displayName || components[uid].modelName,
+      category: components[uid].category,
+      uses: [],
+      usedIn: []
+    };
+  });
+  Object.keys(components).forEach((parentUid) => {
+    const component = components[parentUid];
+    const nestedComponents = findNestedComponents(component.attributes);
+    nestedComponents.forEach(
+      ({ componentUid, attributeName, repeatable, isDynamicZone }) => {
+        graph[parentUid].uses.push({
+          componentUid,
+          attributeName,
+          repeatable,
+          isDynamicZone
+        });
+        if (graph[componentUid]) {
+          graph[componentUid].usedIn.push({
+            componentUid: parentUid,
+            attributeName,
+            repeatable,
+            isDynamicZone
+          });
+        }
+      }
+    );
+  });
+  return graph;
+};
+const componentRelationships = ({ strapi }) => ({
+  getComponentDependencies(componentUid) {
+    const component = strapi.components[componentUid];
+    if (!component) {
+      return [];
+    }
+    return findNestedComponents(component.attributes);
+  },
+  getComponentUsedIn(componentUid) {
+    const usedIn = [];
+    Object.keys(strapi.components).forEach((parentUid) => {
+      const parentComponent = strapi.components[parentUid];
+      const nestedComponents = findNestedComponents(
+        parentComponent.attributes
+      );
+      const isUsed = nestedComponents.some(
+        (nested) => nested.componentUid === componentUid
+      );
+      if (isUsed) {
+        usedIn.push({
+          componentUid: parentUid,
+          displayName: parentComponent.info?.displayName || parentComponent.modelName,
+          category: parentComponent.category,
+          attributes: nestedComponents.filter((nested) => nested.componentUid === componentUid).map((nested) => ({
+            name: nested.attributeName,
+            repeatable: nested.repeatable,
+            isDynamicZone: nested.isDynamicZone
+          }))
+        });
+      }
+    });
+    return usedIn;
+  },
+  getDependencyGraph() {
+    return buildDependencyGraph(strapi.components);
+  },
+  getComponentWithRelationships(componentUid) {
+    const component = strapi.components[componentUid];
+    if (!component) {
+      return null;
+    }
+    return {
+      uid: componentUid,
+      displayName: component.info?.displayName || component.modelName,
+      category: component.category,
+      attributes: component.attributes,
+      uses: this.getComponentDependencies(componentUid),
+      usedIn: this.getComponentUsedIn(componentUid)
+    };
+  },
+  async getTotalUsageCount(componentUid) {
+    const componentUsageService = strapi.plugin("component-usage").service("component-usage");
+    const directUsageCount = await componentUsageService.getComponentUsageCount(componentUid);
+    const usedInComponents = this.getComponentUsedIn(componentUid);
+    return {
+      directUsage: directUsageCount,
+      indirectUsage: usedInComponents.length,
+      totalUsage: directUsageCount + usedInComponents.length,
+      usedInComponents
+    };
+  }
+});
+const services = {
+  "component-usage": componentUsage,
+  "usage-tracker": usageTracker,
+  "component-relationships": componentRelationships
+};
+const kind = "collectionType";
+const collectionName = "component_usage_tracker";
+const info = {
+  singularName: "component-usage-tracker",
+  pluralName: "component-usage-trackers",
+  displayName: "Component Usage Tracker",
+  description: "Tracks component usage across content types"
+};
+const options = {
+  draftAndPublish: false
+};
+const pluginOptions = {
+  "content-manager": {
+    visible: false
+  },
+  "content-type-builder": {
+    visible: false
+  }
+};
+const attributes = {
+  componentUid: {
+    type: "string",
+    required: true,
+    unique: true
+  },
+  componentName: {
+    type: "string",
+    required: true
+  },
+  componentCategory: {
+    type: "string",
+    required: true
+  },
+  usageCount: {
+    type: "integer",
+    "default": 0,
+    required: true
+  },
+  usages: {
+    type: "json",
+    required: false,
+    "default": []
+  },
+  lastUpdated: {
+    type: "datetime"
+  }
+};
+const schema = {
+  kind,
+  collectionName,
+  info,
+  options,
+  pluginOptions,
+  attributes
+};
+const contentTypes = {
+  "component-usage-tracker": { schema }
+};
+const index = {
+  bootstrap,
+  controllers,
+  routes,
+  services,
+  contentTypes
+};
+export {
+  index as default
+};