strapi-plugin-faqchatbot 1.0.0

package/dist/server/index.mjs

@@ -0,0 +1,902 @@
+import OpenAI from "openai";
+const bootstrap = ({ strapi }) => {
+  const UID = "plugin::faqchatbot.faqqa";
+  const updateEmbedding = async (params, existingEntry) => {
+    const { data } = params;
+    const question = data.question ?? existingEntry?.question;
+    const answer = data.answer ?? existingEntry?.answer;
+    if (!question || !answer) return;
+    const textToEmbed = `Q: ${question}
+A: ${answer}`;
+    const embedding = await strapi.plugin("faqchatbot").service("embed").generateEmbedding(textToEmbed);
+    if (embedding) {
+      data.embedding = embedding;
+    }
+  };
+  strapi.db.lifecycles.subscribe({
+    models: [UID],
+    async beforeCreate(event) {
+      await updateEmbedding(event.params);
+    },
+    async beforeUpdate(event) {
+      const { where } = event.params;
+      const existingEntry = await strapi.db.query(UID).findOne({ where });
+      await updateEmbedding(event.params, existingEntry);
+    }
+  });
+};
+const destroy = ({ strapi }) => {
+};
+const register = ({ strapi }) => {
+};
+const config$2 = {
+  default: {},
+  validator() {
+  }
+};
+const kind = "collectionType";
+const collectionName = "chatbot_config_faqqas";
+const info = {
+  singularName: "faqqa",
+  pluralName: "faqqas",
+  displayName: "Chatbot-FAQ"
+};
+const options = {
+  draftAndPublish: true
+};
+const attributes = {
+  question: {
+    type: "string",
+    required: true
+  },
+  answer: {
+    type: "richtext",
+    required: true
+  },
+  embedding: {
+    type: "json"
+  }
+};
+const schema = {
+  kind,
+  collectionName,
+  info,
+  options,
+  attributes
+};
+const faqqa = { schema };
+const contentTypes = {
+  faqqa
+};
+const controller = ({ strapi }) => ({
+  index(ctx) {
+    ctx.body = strapi.plugin("faqchatbot").service("service").getWelcomeMessage();
+  }
+});
+const config$1 = ({ strapi }) => ({
+  async index(ctx) {
+    const settings = await strapi.plugin("faqchatbot").service("config").getConfig();
+    const contentTypes2 = Object.values(strapi.contentTypes).filter((ct) => ct.uid.startsWith("api::")).map((ct) => ({
+      uid: ct.uid,
+      displayName: ct.info.displayName,
+      attributes: Object.keys(ct.attributes).map((attr) => ({
+        name: attr
+      }))
+    }));
+    ctx.body = {
+      settings,
+      contentTypes: contentTypes2
+    };
+  },
+  async update(ctx) {
+    const settings = ctx.request.body;
+    const data = await strapi.plugin("faqchatbot").service("config").setConfig(settings);
+    ctx.body = data;
+  }
+});
+const openai$1 = new OpenAI({
+  apiKey: process.env.OPENAI_API_KEY
+});
+async function getContactLink(strapi) {
+  const pluginStore = strapi.store({
+    environment: null,
+    type: "plugin",
+    name: "faqchatbot"
+  });
+  const settings = await pluginStore.get({ key: "settings" });
+  return settings?.contactLink || null;
+}
+async function getInstructions(strapi) {
+  const pluginStore = strapi.store({
+    environment: null,
+    type: "plugin",
+    name: "faqchatbot"
+  });
+  const settings = await pluginStore.get({ key: "settings" });
+  return {
+    system: settings?.systemInstructions || "",
+    response: settings?.responseInstructions || ""
+  };
+}
+async function getActiveCollections(strapi) {
+  try {
+    const pluginStore = strapi.store({
+      environment: null,
+      type: "plugin",
+      name: "faqchatbot"
+    });
+    const settings = await pluginStore.get({ key: "collections" });
+    if (!settings) return [];
+    const activeList = [];
+    for (const item of settings) {
+      const ignored = ["faqitem", "item"];
+      const name = item.name.toLowerCase();
+      const hasEnabledFields = item.fields?.some((f) => f.enabled);
+      if (!hasEnabledFields || ignored.includes(name)) {
+        continue;
+      }
+      const uid = `api::${item.name}.${item.name}`;
+      const contentType = strapi.contentTypes[uid];
+      if (!contentType) {
+        console.warn(` [WARNING] Content type not found for UID: ${uid}`);
+        continue;
+      }
+      const fields = Object.keys(contentType.attributes).filter((key) => {
+        const attr = contentType.attributes[key];
+        return [
+          "string",
+          "text",
+          "email",
+          "uid",
+          "richtext",
+          "enumeration",
+          "integer",
+          "biginteger",
+          "decimal",
+          "float",
+          "date",
+          "datetime",
+          "time",
+          "relation"
+        ].includes(attr.type);
+      });
+      activeList.push({ name: item.name, fields });
+    }
+    return activeList;
+  } catch (err) {
+    console.error(" [ERROR] Error loading active collections:", err);
+    return [];
+  }
+}
+async function rephraseQuestion(history, question) {
+  if (!history || !Array.isArray(history) || history.length === 0) {
+    return question;
+  }
+  try {
+    const response = await openai$1.chat.completions.create({
+      model: "gpt-4o-mini",
+      temperature: 0,
+      messages: [
+        {
+          role: "system",
+          content: `You are a Search Query Optimizer.
+        Your task is to determine if the user's new message is a **Follow-up** or a **New Topic** and if a follow-up just rewrite the question .
+        Do NOT return any explanations, only the optimized search string.
+
+        ### RULES
+        1. **Dependency Check (The "Pronoun" Rule):**
+           - ONLY combine with history if the new question contains **Pronouns** ("it", "that", "they") or is **Grammatically Incomplete** ("How much?", "Where do I buy?", "Is it refundable?").
+           
+        2. **Independence Check (The "Specifics" Rule):**
+           - If the user asks a complete question containing a **New Specific Noun** or **Scenario** (e.g., "Group of 7 people", "Booking for pets"), treat it as a **Standalone Query**.
+           - **Do NOT** attach the previous topic to it.
+           - *Example:* History="Commuter Pass", Input="Can I book for a group of 7?" -> Output="Group booking for 7 people" (Correct).
+           - *Bad Output:* "Group booking for Commuter Pass" (Incorrect).
+
+        3. **Output:**
+           - Return ONLY the optimized search string.`
+        },
+        ...history.slice(-4),
+        { role: "user", content: question }
+      ]
+    });
+    const rewritten = response.choices[0].message.content?.trim();
+    if (!rewritten) return question;
+    const lower = rewritten.toLowerCase();
+    if (lower.includes("unavailable") || lower.includes("sorry") || lower.includes("i am") || lower.includes("cannot") || rewritten.length > 120) {
+      return question;
+    }
+    return rewritten;
+  } catch (err) {
+    console.error("Error in rephraseQuestion:", err);
+    return question;
+  }
+}
+function sanitizeFilters(filters) {
+  if (!filters || typeof filters !== "object") return filters;
+  if (Array.isArray(filters)) {
+    return filters.map(sanitizeFilters);
+  }
+  const operators = [
+    "eq",
+    "ne",
+    "lt",
+    "gt",
+    "lte",
+    "gte",
+    "in",
+    "notIn",
+    "contains",
+    "notContains",
+    "containsi",
+    "notContainsi",
+    "null",
+    "notNull",
+    "between",
+    "startsWith",
+    "endsWith",
+    "or",
+    "and",
+    "not"
+  ];
+  const newFilters = {};
+  for (const key in filters) {
+    let newKey = key;
+    if (operators.includes(key) && !key.startsWith("$")) {
+      newKey = `$${key}`;
+    }
+    newFilters[newKey] = sanitizeFilters(filters[key]);
+  }
+  return newFilters;
+}
+function updateJsonContext(prevContext, question) {
+  const MAX_HISTORY = 10;
+  const ctx = { ...prevContext || {} };
+  ctx.history = Array.isArray(ctx.history) ? ctx.history : [];
+  ctx.history.push(question);
+  if (ctx.history.length > MAX_HISTORY) ctx.history.shift();
+  const words = question.toLowerCase().replace(/[^\w\s]/g, "").split(" ").filter((w) => w.length > 3);
+  ctx.keywords = [.../* @__PURE__ */ new Set([...ctx.keywords || [], ...words])];
+  ctx.lastQuestion = question;
+  return ctx;
+}
+async function searchRealtime(strapi, plan, activeCollections) {
+  if (!plan || !plan.collection) {
+    return null;
+  }
+  const sanitizedFilters = sanitizeFilters(plan.filters || {});
+  const config2 = activeCollections.find((c) => c.name === plan.collection);
+  if (!config2) {
+    return null;
+  }
+  const uid = `api::${plan.collection}.${plan.collection}`;
+  try {
+    if (plan.operation === "count") {
+      const count = await strapi.entityService.count(uid, {
+        filters: sanitizedFilters
+      });
+      return {
+        type: "count",
+        collection: plan.collection,
+        value: count
+      };
+    }
+    const result = await strapi.entityService.findMany(uid, {
+      filters: sanitizedFilters,
+      sort: plan.sort,
+      limit: 10
+    });
+    const cleaned = result.map((row) => {
+      const clean = {};
+      for (const f of config2.fields) clean[f] = row[f];
+      return clean;
+    });
+    return {
+      type: "list",
+      collection: plan.collection,
+      schema: config2.fields,
+      items: cleaned
+    };
+  } catch (err) {
+    console.error("Realtime search error:", err);
+    return null;
+  }
+}
+function cosineSimilarity(a, b) {
+  if (!a || !b || a.length !== b.length) return 0;
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+async function searchFAQ(question, strapi) {
+  const embedding = await openai$1.embeddings.create({
+    model: "text-embedding-3-small",
+    input: question
+  });
+  let queryVector = embedding.data[0].embedding;
+  if (!queryVector || !queryVector.length) {
+    return [];
+  }
+  const faqs = await strapi.db.connection("chatbot_config_faqqas").select("answer", "embedding").whereNotNull("embedding").whereNotNull("published_at");
+  if (!faqs.length) return [];
+  const scored = faqs.map((f) => {
+    let dbVector = f.embedding;
+    try {
+      if (typeof dbVector === "string") {
+        dbVector = JSON.parse(dbVector);
+      }
+      dbVector = Array.isArray(dbVector) ? dbVector.map((n) => Number(n)) : [];
+      if (!Array.isArray(dbVector) || dbVector.length !== queryVector.length) {
+        return { answer: f.answer, similarity: 0 };
+      }
+      return {
+        answer: f.answer,
+        similarity: cosineSimilarity(queryVector, dbVector)
+      };
+    } catch (err) {
+      return { answer: f.answer, similarity: 0 };
+    }
+  });
+  scored.sort((a, b) => b.similarity - a.similarity);
+  if (!scored.length || scored[0].similarity < 0.4) {
+    return [];
+  }
+  return scored.slice(0, 3).map((s) => s.answer);
+}
+async function simplePlanner(question, activeCollections, instructions) {
+  const response = await openai$1.chat.completions.create({
+    model: "gpt-4o-mini",
+    temperature: 0,
+    messages: [
+      {
+        role: "system",
+        content: `
+        ${instructions.system || ""}
+You are a STRICT database query planner that converts user questions into Strapi query JSON.
+
+--------------------------------
+CORE TASK
+--------------------------------
+Return ONLY valid JSON. No text. No explanation.
+
+--------------------------------
+COLLECTION SELECTION
+--------------------------------
+- Choose the most relevant collection from the available list.
+- Never invent collection names.
+
+--------------------------------
+FIELD RULES
+--------------------------------
+- Only use fields that exist in the selected collection schema.
+- Never hallucinate fields.
+
+
+--------------------------------
+LOCATION NORMALIZATION (CRITICAL)
+--------------------------------
+The database stores locations in the format:
+City Name (AIRPORT_CODE)
+
+Before generating filters, you MUST normalize
+all user-provided places into the nearest
+major city or airport name.
+
+RULES:
+
+1. SMALL TOWNS / VILLAGES
+- Convert to nearest major airport city.
+Example:
+"Kalveerampalayam" → "Coimbatore"
+"Kollam" → "Trivandrum"
+"Alappuzha" → "Kochi"
+
+2. OLD OR LOCAL NAMES
+- Convert to modern official city name.
+Example:
+"Madras" → "Chennai"
+"Cochin" → "Kochi"
+"Bombay" → "Mumbai"
+
+3. SUBURBS / DISTRICTS
+- Convert to main metro city.
+Example:
+"Brooklyn" → "New York"
+"Noida" → "Delhi"
+
+4. AIRPORT CODES
+- If user provides code (COK, MAA, JFK),
+search using containsi for that code.
+
+Example:
+User: "flight from COK"
+Filter:
+{ "origin": { "containsi": "COK" } }
+
+5. ALWAYS MATCH DATABASE STRINGS
+- Use containsi
+- Never use raw spelling if DB format differs
+- Prefer airport code if available
+
+--------------------------------
+TEXT FILTER RULES (VERY IMPORTANT)
+--------------------------------
+- For city names, titles, destinations, names → ALWAYS use "containsi"
+- NEVER use "eq" for text
+- NEVER use "in" for text arrays
+- For multiple text values use "$or" with containsi
+
+Example:
+User: "flight to paris or amsterdam"
+Filters:
+{
+  "$or": [
+    { "destination": { "containsi": "paris" } },
+    { "destination": { "containsi": "amsterdam" } }
+  ]
+}
+
+--------------------------------
+NUMBER FILTER RULES
+--------------------------------
+- For price, fare, amount → use lt, lte, gt, gte, between
+- "under" → lte
+- "above" → gte
+- "between" → between
+
+--------------------------------
+OPERATION RULES
+--------------------------------
+- "how many", "count" → operation = "count"
+- otherwise → operation = "list"
+
+--------------------------------
+SORT RULES
+--------------------------------
+- "cheapest", "lowest" → sort ["fare:asc"]
+- "highest", "expensive" → sort ["fare:desc"]
+- Only add sort if user implies ranking
+
+--------------------------------
+INTENT CLASSIFICATION (CRITICAL)
+--------------------------------
+First decide intent:
+
+INTENT = "realtime"
+- User asks about availability, price, list, count, search, show items
+- Mentions data stored in collections
+
+INTENT = "faq"
+- User asks "who is", "what is", "explain", "details about"
+- General knowledge
+- No clear database entity
+
+If no clear database match → ALWAYS choose "faq"
+NEVER force a collection.
+
+OUTPUT FORMAT
+
+Return ONLY JSON.
+
+If no database match exists, return:
+
+{
+  "collection": null
+}
+
+Otherwise return:
+
+{
+  "collection": "name",
+  "operation": "list" | "count",
+  "filters": {},
+  "sort": []
+}
+
+
+--------------------------------
+AVAILABLE COLLECTIONS
+--------------------------------
+${JSON.stringify(activeCollections, null, 2)}
+`
+      },
+      {
+        role: "user",
+        content: question
+      }
+    ]
+  });
+  try {
+    const raw = response.choices[0].message.content || "{}";
+    const cleaned = raw.replace(/```json/g, "").replace(/```/g, "").trim();
+    const plan = JSON.parse(cleaned);
+    return plan;
+  } catch (err) {
+    return null;
+  }
+}
+async function realtimeInterpreterAI(question, realtimeData) {
+  if (!realtimeData) return null;
+  const response = await openai$1.chat.completions.create({
+    model: "gpt-4o-mini",
+    temperature: 0.2,
+    messages: [
+      {
+        role: "system",
+        content: `
+You are a realtime data interpreter.
+
+Convert database JSON into a SHORT natural language summary.
+
+Rules:
+- Do NOT output JSON
+- Do NOT hallucinate
+- If count → say number
+- If list → summarize important fields only
+- Max 3–4 lines
+`
+      },
+      {
+        role: "user",
+        content: `
+QUESTION: ${question}
+
+REALTIME DATA:
+${JSON.stringify(realtimeData)}
+`
+      }
+    ]
+  });
+  const text = response.choices[0].message.content;
+  return text;
+}
+async function finalAggregator(ctx, question, faq, realtimeMeta, realtimeText, contactLink, instructions) {
+  ctx.set("Content-Type", "text/event-stream");
+  ctx.set("Cache-Control", "no-cache");
+  ctx.set("Connection", "keep-alive");
+  ctx.status = 200;
+  ctx.res.flushHeaders?.();
+  const stream = await openai$1.chat.completions.create({
+    model: "gpt-4o-mini",
+    temperature: 0.3,
+    stream: true,
+    messages: [
+      {
+        role: "system",
+        content: `
+
+        ${instructions.response || ""}
+You are an intelligent AI Assistant for a website chatbot.
+
+INPUTS:
+- FAQ semantic answers
+- REALTIME_META (structured database info)
+- REALTIME_TEXT (human summary)
+- User question
+
+--------------------------------
+RESPONSE LENGTH RULE
+--------------------------------
+Default → SHORT & PRECISE (2–3 lines max)
+
+If the user's question contains:
+"explain", "details", "more", "elaborate", "why", "how"
+→ Provide LONGER detailed answer.
+
+If FAQ answer is long:
+→ Summarize unless user asked for detail.
+
+--------------------------------
+CORE RULE
+--------------------------------
+REALTIME_META decides logic.
+REALTIME_TEXT decides wording.
+
+--------------------------------
+CONTACT INTENT RULE
+--------------------------------
+If user asks about contacting support, customer service, help, or similar:
+
+AND contactLink is provided:
+Return ONLY this link in a short sentence.
+
+Example:
+"You can contact us here: https://example.com/contact"
+
+--------------------------------
+ANSWER LOGIC
+--------------------------------
+
+CASE 1 — REALTIME_META.type = "count"
+Return ONE sentence with the number.
+
+CASE 2 — REALTIME_META.type = "list"
+Use REALTIME_TEXT as main answer.
+
+CASE 3 — REALTIME_META = null
+Use FAQ.
+
+CASE 4 — BOTH EXIST
+Use REALTIME_TEXT as main + FAQ as support.
+
+CASE 5 — NOTHING
+Say information unavailable.
+
+Never show JSON.
+Never hallucinate.
+Max 5 lines.
+`
+      },
+      {
+        role: "user",
+        content: `
+QUESTION: ${question}
+
+CONTACT_LINK:
+${contactLink || "NOT_AVAILABLE"}
+
+FAQ:
+${JSON.stringify(faq)}
+
+REALTIME_META:
+${JSON.stringify(realtimeMeta)}
+
+REALTIME_TEXT:
+${realtimeText}
+`
+      }
+    ]
+  });
+  for await (const chunk of stream) {
+    const token = chunk.choices?.[0]?.delta?.content;
+    if (token) {
+      ctx.res.write(`data: ${token}
+
+`);
+    }
+  }
+  if (realtimeMeta && realtimeMeta.type === "list") {
+    const cardsPayload = {
+      title: realtimeMeta.collection,
+      schema: realtimeMeta.schema,
+      items: realtimeMeta.items
+    };
+    ctx.res.write(`event: cards
+`);
+    ctx.res.write(`data: ${JSON.stringify(cardsPayload)}
+
+`);
+  }
+  ctx.res.write("data: [DONE]\n\n");
+  ctx.res.end();
+}
+async function validateOpenAIKey(key) {
+  try {
+    const temp = new OpenAI({ apiKey: key });
+    await temp.models.list();
+    return true;
+  } catch {
+    return false;
+  }
+}
+const ask = ({ strapi }) => ({
+  async validateKey(ctx) {
+    const { key } = ctx.request.body;
+    const isValid = await validateOpenAIKey(key);
+    ctx.body = { valid: isValid };
+  },
+  async ask(ctx) {
+    const { question, history = [] } = ctx.request.body;
+    const instructions = await getInstructions(strapi);
+    let jsonContext = ctx.request.body.context || {};
+    jsonContext = updateJsonContext(jsonContext, question);
+    ctx.set("X-User-Context", JSON.stringify(jsonContext));
+    try {
+      const activeCollections = await getActiveCollections(strapi);
+      if (!activeCollections || activeCollections.length === 0) {
+      }
+      const rewritten = await rephraseQuestion(history, question);
+      const contactLink = await getContactLink(strapi);
+      const faqResults = await searchFAQ(rewritten, strapi);
+      const plan = await simplePlanner(rewritten, activeCollections, instructions);
+      let realtimeResults = null;
+      let realtimeAIText = null;
+      if (plan && plan.collection) {
+        realtimeResults = await searchRealtime(strapi, plan, activeCollections);
+        realtimeAIText = await realtimeInterpreterAI(rewritten, realtimeResults);
+      } else {
+      }
+      await finalAggregator(
+        ctx,
+        rewritten,
+        faqResults,
+        realtimeResults,
+        realtimeAIText,
+        contactLink,
+        instructions
+      );
+      return;
+    } catch (err) {
+      console.error("[ERROR]", err);
+      ctx.body = { type: "text", content: "Error occurred." };
+    }
+  }
+});
+const suggestQuestions = ({ strapi }) => ({
+  async getSuggested(ctx) {
+    const pluginStore = strapi.store({
+      environment: null,
+      type: "plugin",
+      name: "faqchatbot"
+    });
+    const settings = await pluginStore.get({ key: "settings" });
+    ctx.body = {
+      suggestedQuestions: settings?.suggestedQuestions || []
+    };
+  }
+});
+const cardMapping = ({ strapi }) => ({
+  async index(ctx) {
+    const pluginStore = strapi.store({
+      environment: null,
+      type: "plugin",
+      name: "faqchatbot"
+    });
+    const settings = await pluginStore.get({ key: "settings" });
+    ctx.body = {
+      cardStyles: settings?.cardStyles || {}
+    };
+  }
+});
+const controllers = {
+  controller,
+  config: config$1,
+  ask,
+  suggestQuestions,
+  cardMapping
+};
+const middlewares = {};
+const policies = {};
+const admin = {
+  type: "admin",
+  routes: [
+    {
+      method: "GET",
+      path: "/collections",
+      handler: "config.index",
+      config: {
+        auth: false
+      }
+    },
+    {
+      method: "POST",
+      path: "/collections",
+      handler: "config.update",
+      config: {
+        auth: false
+      }
+    }
+  ]
+};
+const contentApi = () => ({
+  type: "content-api",
+  routes: [
+    {
+      method: "GET",
+      path: "/",
+      handler: "controller.index",
+      config: {
+        auth: false
+      }
+    },
+    {
+      method: "POST",
+      path: "/ask",
+      handler: "ask.ask",
+      config: {
+        auth: false
+      }
+    },
+    {
+      method: "GET",
+      path: "/suggested-questions",
+      handler: "suggestQuestions.getSuggested",
+      config: {
+        auth: false
+      }
+    },
+    {
+      method: "GET",
+      path: "/card-mapping",
+      handler: "cardMapping.index",
+      config: { auth: false }
+    },
+    {
+      method: "POST",
+      path: "/validate-key",
+      handler: "ask.validateKey",
+      config: {
+        auth: false
+      }
+    }
+  ]
+});
+const routes = {
+  admin,
+  "content-api": contentApi
+};
+const openai = new OpenAI({
+  apiKey: process.env.OPENAI_API_KEY
+});
+const embed = ({ strapi }) => ({
+  async generateEmbedding(text) {
+    try {
+      if (!process.env.OPENAI_API_KEY) {
+        return null;
+      }
+      const response = await openai.embeddings.create({
+        model: "text-embedding-3-small",
+        input: text
+      });
+      return response.data[0].embedding;
+    } catch (error) {
+      strapi.log.error("Error generating embedding via OpenAI:");
+      console.error(error);
+      return null;
+    }
+  }
+});
+const config = ({ strapi }) => ({
+  async getConfig() {
+    const pluginStore = strapi.store({
+      environment: null,
+      type: "plugin",
+      name: "faqchatbot"
+    });
+    const settings = await pluginStore.get({ key: "settings" });
+    return settings && typeof settings === "object" ? settings : {};
+  },
+  async setConfig(newSettings) {
+    const pluginStore = strapi.store({
+      environment: null,
+      type: "plugin",
+      name: "faqchatbot"
+    });
+    const existingRaw = await pluginStore.get({ key: "settings" });
+    const existingSettings = existingRaw && typeof existingRaw === "object" ? existingRaw : {};
+    const mergedSettings = {
+      ...existingSettings,
+      ...newSettings
+    };
+    await pluginStore.set({
+      key: "settings",
+      value: mergedSettings
+    });
+    return mergedSettings;
+  }
+});
+const services = {
+  config,
+  embed
+};
+const index = {
+  register,
+  bootstrap,
+  destroy,
+  config: config$2,
+  controllers,
+  routes,
+  services,
+  contentTypes,
+  policies,
+  middlewares
+};
+export {
+  index as default
+};