strapi-plugin-meilisearch-plus 0.0.1

package/dist/server/index.mjs

@@ -0,0 +1,1347 @@
+import { MeiliSearch } from "meilisearch";
+const bootstrap = ({ strapi }) => {
+  try {
+    strapi.log.info("[meilisearch-plus] Bootstrapping plugin");
+    const storeService = strapi.plugin("meilisearch-plus").service("store");
+    const lifecycleService = strapi.plugin("meilisearch-plus").service("lifecycle");
+    const meilisearchService = strapi.plugin("meilisearch-plus").service("meilisearch");
+    (async () => {
+      try {
+        await storeService.syncCredentials();
+        strapi.log.info("[meilisearch-plus] Credentials synced from plugin config");
+        await meilisearchService.syncIndexedCollections();
+        const indexedContentTypes = await storeService.getIndexedContentTypes();
+        if (indexedContentTypes && indexedContentTypes.length > 0) {
+          strapi.log.info(
+            `[meilisearch-plus] Subscribing to ${indexedContentTypes.length} indexed content types:`,
+            indexedContentTypes
+          );
+          for (const contentType of indexedContentTypes) {
+            try {
+              lifecycleService.subscribeContentType(contentType);
+            } catch (error) {
+              strapi.log.warn(`[meilisearch-plus] Failed to subscribe to ${contentType}:`, error);
+            }
+          }
+        } else {
+          strapi.log.info("[meilisearch-plus] No indexed content types found");
+        }
+        strapi.log.info("[meilisearch-plus] Bootstrap complete");
+      } catch (error) {
+        strapi.log.error("[meilisearch-plus] Bootstrap error:", error);
+      }
+    })();
+  } catch (error) {
+    strapi.log.error("[meilisearch-plus] Bootstrap initialization error:", error);
+  }
+};
+const destroy = ({ strapi }) => {
+  try {
+    strapi.log.info("[meilisearch-plus] Destroying plugin");
+  } catch (error) {
+    strapi.log.error("[meilisearch-plus] Destroy error:", error);
+  }
+};
+const register = ({ strapi }) => {
+  strapi.log.info("[meilisearch-plus] Registering plugin");
+};
+const config = {
+  default: {},
+  validator() {
+  }
+};
+const contentTypes$2 = {};
+const credentials = ({ strapi }) => ({
+  async index(ctx) {
+    ctx.body = { message: "MeiliSearch Plus API" };
+  },
+  async getCredentials(ctx) {
+    try {
+      const storeService = strapi.plugin("meilisearch-plus").service("store");
+      const credentials2 = await storeService.getCredentials();
+      ctx.body = { data: credentials2 };
+    } catch (error) {
+      strapi.log.error("[meilisearch-plus] Failed to get credentials:", error);
+      ctx.body = { error: error.message };
+      ctx.status = 500;
+    }
+  },
+  async setCredentials(ctx) {
+    try {
+      const { host, apiKey, indexName } = ctx.request.body;
+      const storeService = strapi.plugin("meilisearch-plus").service("store");
+      await storeService.setCredentials({ host, apiKey, indexName });
+      const credentials2 = await storeService.getCredentials();
+      ctx.body = { data: credentials2 };
+    } catch (error) {
+      strapi.log.error("[meilisearch-plus] Failed to set credentials:", error);
+      ctx.body = { error: error.message };
+      ctx.status = 500;
+    }
+  },
+  async testConnection(ctx) {
+    try {
+      const storeService = strapi.plugin("meilisearch-plus").service("store");
+      const clientService = strapi.plugin("meilisearch-plus").service("meilisearch-client");
+      const credentials2 = await storeService.getCredentials();
+      const client = clientService.createClient(credentials2);
+      const isHealthy = await clientService.testConnection(client);
+      ctx.body = { data: { healthy: isHealthy } };
+    } catch (error) {
+      strapi.log.error("[meilisearch-plus] Connection test failed:", error);
+      ctx.body = { error: error.message, data: { healthy: false } };
+      ctx.status = 500;
+    }
+  }
+});
+const search = ({ strapi }) => ({
+  async search(ctx) {
+    try {
+      const { query, filters, limit = 20, offset = 0 } = ctx.request.body;
+      if (!query) {
+        ctx.status = 400;
+        ctx.body = { error: "Query parameter is required" };
+        return;
+      }
+      const meilisearchService = strapi.plugin("meilisearch-plus").service("meilisearch");
+      const storeService = strapi.plugin("meilisearch-plus").service("store");
+      const indexName = await storeService.getIndexName();
+      if (!indexName) {
+        ctx.status = 400;
+        ctx.body = { error: "Index name not configured" };
+        return;
+      }
+      const results = await meilisearchService.search({
+        query,
+        filters,
+        limit,
+        offset,
+        indexName
+      });
+      ctx.body = { data: results };
+    } catch (error) {
+      strapi.log.error("[meilisearch-plus] Search failed:", error);
+      ctx.body = { error: error.message };
+      ctx.status = 500;
+    }
+  },
+  async getIndexStatus(ctx) {
+    try {
+      const storeService = strapi.plugin("meilisearch-plus").service("store");
+      const clientService = strapi.plugin("meilisearch-plus").service("meilisearch-client");
+      const credentials2 = await storeService.getCredentials();
+      const indexName = await storeService.getIndexName();
+      if (!indexName) {
+        ctx.body = { data: { status: "not-configured" } };
+        return;
+      }
+      const client = clientService.createClient(credentials2);
+      if (!client) {
+        ctx.body = { data: { status: "disconnected" } };
+        return;
+      }
+      const isHealthy = await clientService.testConnection(client);
+      if (!isHealthy) {
+        ctx.body = { data: { status: "unhealthy" } };
+        return;
+      }
+      const indexUids = await clientService.getIndexUids(client);
+      const indexExists = indexUids.includes(indexName);
+      if (!indexExists) {
+        ctx.body = { data: { status: "index-missing" } };
+        return;
+      }
+      const indexedContentTypes = await storeService.getIndexedContentTypes();
+      const stats = {
+        status: "healthy",
+        indexName,
+        indexedContentTypes: indexedContentTypes || [],
+        totalIndexes: indexUids.length
+      };
+      ctx.body = { data: stats };
+    } catch (error) {
+      strapi.log.error("[meilisearch-plus] Failed to get index status:", error);
+      ctx.body = { error: error.message };
+      ctx.status = 500;
+    }
+  }
+});
+const contentTypes$1 = ({ strapi }) => ({
+  async getConfiguredContentTypes(ctx) {
+    try {
+      let pluginConfig = strapi.config.get("plugin::meilisearch-plus");
+      strapi.log.info("[meilisearch-plus] Accessed via plugin::meilisearch-plus:", !!pluginConfig);
+      if (!pluginConfig) {
+        pluginConfig = strapi.config.get("plugins")?.["meilisearch-plus"];
+        strapi.log.info(
+          "[meilisearch-plus] Accessed via plugins.meilisearch-plus:",
+          !!pluginConfig
+        );
+      }
+      pluginConfig = pluginConfig || {};
+      strapi.log.info(
+        "[meilisearch-plus] Final plugin config:",
+        JSON.stringify(pluginConfig, null, 2)
+      );
+      const configured = Object.keys(pluginConfig).filter(
+        (key) => key !== "host" && key !== "apiKey" && key !== "enabled" && key !== "resolve" && typeof pluginConfig[key] === "object"
+      );
+      strapi.log.info("[meilisearch-plus] Configured content types:", configured);
+      ctx.body = { data: configured };
+    } catch (error) {
+      strapi.log.error("[meilisearch-plus] Failed to get configured content types:", error);
+      ctx.body = { error: error.message };
+      ctx.status = 500;
+    }
+  },
+  async getSyncStatus(ctx) {
+    try {
+      const contentTypeService = strapi.plugin("meilisearch-plus").service("content-types");
+      const { contentType } = ctx.query;
+      if (!contentType) {
+        ctx.status = 400;
+        ctx.body = { error: "Content type is required" };
+        return;
+      }
+      const syncStatus = await contentTypeService.getSyncStatus({ contentType });
+      ctx.body = { data: syncStatus };
+    } catch (error) {
+      strapi.log.error("[meilisearch-plus] Failed to get sync status:", error);
+      ctx.body = { error: error.message };
+      ctx.status = 500;
+    }
+  },
+  async getAllSyncStatus(ctx) {
+    try {
+      const contentTypeService = strapi.plugin("meilisearch-plus").service("content-types");
+      const storeService = strapi.plugin("meilisearch-plus").service("store");
+      let pluginConfig = strapi.config.get("plugin::meilisearch-plus");
+      if (!pluginConfig) {
+        pluginConfig = strapi.config.get("plugins")?.["meilisearch-plus"] || {};
+      }
+      const configuredShortNames = Object.keys(pluginConfig).filter(
+        (key) => key !== "host" && key !== "apiKey" && key !== "enabled" && key !== "resolve" && typeof pluginConfig[key] === "object"
+      );
+      const allContentTypes = strapi.contentTypes;
+      const shortNameToUid = {};
+      Object.keys(allContentTypes).forEach((uid) => {
+        const lastPart = uid.split(".").pop();
+        if (lastPart && configuredShortNames.includes(lastPart)) {
+          shortNameToUid[lastPart] = uid;
+        }
+      });
+      const configuredUids = configuredShortNames.map((short) => shortNameToUid[short]).filter(Boolean);
+      const indexed = await storeService.getIndexedContentTypes();
+      const syncStatuses = await contentTypeService.getSyncStatusForMultiple({
+        contentTypes: configuredUids
+      });
+      const result = configuredUids.map((uid) => ({
+        contentType: uid,
+        displayName: allContentTypes[uid]?.info?.displayName || uid,
+        ...syncStatuses[uid],
+        isIndexed: indexed.includes(uid)
+      }));
+      ctx.body = { data: result };
+    } catch (error) {
+      strapi.log.error("[meilisearch-plus] Failed to get all sync statuses:", error);
+      ctx.body = { error: error.message };
+      ctx.status = 500;
+    }
+  },
+  async getIndexedContentTypes(ctx) {
+    try {
+      const storeService = strapi.plugin("meilisearch-plus").service("store");
+      const indexedContentTypes = await storeService.getIndexedContentTypes();
+      ctx.body = { data: indexedContentTypes || [] };
+    } catch (error) {
+      strapi.log.error("[meilisearch-plus] Failed to get indexed content types:", error);
+      ctx.body = { error: error.message };
+      ctx.status = 500;
+    }
+  },
+  async addIndexedContentType(ctx) {
+    try {
+      const { contentType } = ctx.request.body;
+      if (!contentType) {
+        ctx.status = 400;
+        ctx.body = { error: "Content type is required" };
+        return;
+      }
+      const storeService = strapi.plugin("meilisearch-plus").service("store");
+      const lifecycleService = strapi.plugin("meilisearch-plus").service("lifecycle");
+      await storeService.addIndexedContentType(contentType);
+      lifecycleService.subscribeContentType(contentType);
+      const indexedContentTypes = await storeService.getIndexedContentTypes();
+      ctx.body = { data: indexedContentTypes };
+    } catch (error) {
+      strapi.log.error("[meilisearch-plus] Failed to add indexed content type:", error);
+      ctx.body = { error: error.message };
+      ctx.status = 500;
+    }
+  },
+  async removeIndexedContentType(ctx) {
+    try {
+      const { contentType } = ctx.query;
+      if (!contentType) {
+        ctx.status = 400;
+        ctx.body = { error: "Content type is required" };
+        return;
+      }
+      const storeService = strapi.plugin("meilisearch-plus").service("store");
+      const lifecycleService = strapi.plugin("meilisearch-plus").service("lifecycle");
+      const meilisearchService = strapi.plugin("meilisearch-plus").service("meilisearch");
+      await meilisearchService.emptyOrDeleteIndex({ contentType });
+      await storeService.removeIndexedContentType(contentType);
+      lifecycleService.unsubscribeContentType(contentType);
+      const indexedContentTypes = await storeService.getIndexedContentTypes();
+      ctx.body = { data: indexedContentTypes };
+    } catch (error) {
+      strapi.log.error("[meilisearch-plus] Failed to remove indexed content type:", error);
+      ctx.body = { error: error.message };
+      ctx.status = 500;
+    }
+  }
+});
+const indexing = ({ strapi }) => ({
+  async reindexContentType(ctx) {
+    try {
+      const { contentType } = ctx.request.body || ctx.params;
+      if (!contentType) {
+        ctx.status = 400;
+        ctx.body = { error: "Content type is required" };
+        return;
+      }
+      const meilisearchService = strapi.plugin("meilisearch-plus").service("meilisearch");
+      const taskUids = await meilisearchService.updateContentTypeInMeiliSearch({ contentType });
+      ctx.body = { data: { reindexed: taskUids.length } };
+    } catch (error) {
+      strapi.log.error("[meilisearch-plus] Reindexing failed:", error);
+      ctx.body = { error: error.message };
+      ctx.status = 500;
+    }
+  },
+  async clearIndex(ctx) {
+    try {
+      const meilisearchService = strapi.plugin("meilisearch-plus").service("meilisearch");
+      const { contentType } = ctx.request.body || {};
+      await meilisearchService.deleteAllDocuments({ contentType });
+      ctx.body = { data: { cleared: true } };
+    } catch (error) {
+      strapi.log.error("[meilisearch-plus] Clear index failed:", error);
+      ctx.body = { error: error.message };
+      ctx.status = 500;
+    }
+  }
+});
+const indexSettings = ({ strapi }) => ({
+  /**
+   * Get all indexed content types and their fields for attribute selection
+   */
+  async getContentTypesAndFields(ctx) {
+    try {
+      const storeService = strapi.plugin("meilisearch-plus").service("store");
+      const indexedContentTypes = await storeService.getIndexedContentTypes();
+      const fields = {};
+      const filterableAttributes = {};
+      const sortableAttributes = {};
+      for (const contentType of indexedContentTypes) {
+        try {
+          const model = strapi.getModel(contentType);
+          if (!model || !model.attributes) {
+            strapi.log.warn(
+              `[meilisearch-plus] Could not find model for content type: ${contentType}`
+            );
+            continue;
+          }
+          fields[contentType] = [
+            ...Object.entries(model.attributes).filter(([_, attr]) => {
+              const type = attr.type;
+              return type === "string" || type === "text" || type === "richtext" || type === "email" || type === "integer" || type === "decimal" || type === "biginteger" || type === "float" || type === "boolean" || type === "date" || type === "datetime" || type === "time" || type === "enumeration";
+            }).map(([name]) => name)
+          ];
+          filterableAttributes[contentType] = {};
+          sortableAttributes[contentType] = {};
+        } catch (err) {
+          strapi.log.error(`[meilisearch-plus] Error processing content type ${contentType}:`, err);
+        }
+      }
+      const storedSettings = await storeService.getStoreKey({
+        key: "meilisearch-index-settings"
+      });
+      if (storedSettings) {
+        const storedFilterable = storedSettings.filterableAttributes || [];
+        const storedSortable = storedSettings.sortableAttributes || [];
+        indexedContentTypes.forEach((contentType) => {
+          storedFilterable.forEach((field) => {
+            if (fields[contentType]?.includes(field)) {
+              filterableAttributes[contentType][field] = true;
+            }
+          });
+          storedSortable.forEach((field) => {
+            if (fields[contentType]?.includes(field)) {
+              sortableAttributes[contentType][field] = true;
+            }
+          });
+        });
+        strapi.log.info(
+          `[meilisearch-plus] Loaded stored settings: filterable=[${storedFilterable.join(", ")}], sortable=[${storedSortable.join(", ")}]`
+        );
+      }
+      const storedMaxHits = await storeService.getStoreKey({
+        key: "meilisearch-max-total-hits"
+      });
+      ctx.body = {
+        contentTypes: indexedContentTypes.map((uid) => ({
+          uid,
+          name: strapi.getModel(uid)?.info?.displayName || uid
+        })),
+        fields,
+        filterableAttributes,
+        sortableAttributes,
+        maxTotalHits: storedMaxHits || 1e3
+      };
+    } catch (error) {
+      strapi.log.error("[meilisearch-plus] Error in getContentTypesAndFields:", error);
+      ctx.throw(500, error.message);
+    }
+  },
+  /**
+   * Save index settings (filterable/sortable attributes and maxTotalHits)
+   */
+  async saveIndexSettings(ctx) {
+    try {
+      const { filterableAttributes, sortableAttributes, maxTotalHits } = ctx.request.body;
+      const storeService = strapi.plugin("meilisearch-plus").service("store");
+      strapi.log.info("[meilisearch-plus] saveIndexSettings received maxTotalHits:", maxTotalHits);
+      const mergedFilterableAttributes = [];
+      const mergedSortableAttributes = [];
+      for (const [contentType, attrs] of Object.entries(filterableAttributes)) {
+        if (Array.isArray(attrs)) {
+          attrs.forEach((field) => {
+            if (!mergedFilterableAttributes.includes(field)) {
+              mergedFilterableAttributes.push(field);
+            }
+          });
+        }
+      }
+      for (const [contentType, attrs] of Object.entries(sortableAttributes)) {
+        if (Array.isArray(attrs)) {
+          attrs.forEach((field) => {
+            if (!mergedSortableAttributes.includes(field)) {
+              mergedSortableAttributes.push(field);
+            }
+          });
+        }
+      }
+      if (!mergedFilterableAttributes.includes("_contentType")) {
+        mergedFilterableAttributes.unshift("_contentType");
+      }
+      if (!mergedSortableAttributes.includes("_contentType")) {
+        mergedSortableAttributes.unshift("_contentType");
+      }
+      await storeService.setStoreKey({
+        key: "meilisearch-index-settings",
+        value: {
+          filterableAttributes: mergedFilterableAttributes,
+          sortableAttributes: mergedSortableAttributes
+        }
+      });
+      strapi.log.info(
+        `[meilisearch-plus] Saved merged index settings: filterable=[${mergedFilterableAttributes.join(", ")}], sortable=[${mergedSortableAttributes.join(", ")}]`
+      );
+      if (maxTotalHits) {
+        await storeService.setStoreKey({
+          key: "meilisearch-max-total-hits",
+          value: maxTotalHits
+        });
+        strapi.log.info(`[meilisearch-plus] Saved maxTotalHits: ${maxTotalHits}`);
+      }
+      ctx.body = {
+        data: {
+          message: "Index settings saved successfully"
+        }
+      };
+    } catch (error) {
+      strapi.log.error("[meilisearch-plus] Error in saveIndexSettings:", error);
+      ctx.throw(500, error.message);
+    }
+  },
+  /**
+   * Apply current settings to Meilisearch index
+   */
+  async applyIndexSettings(ctx) {
+    try {
+      const storeService = strapi.plugin("meilisearch-plus").service("store");
+      const meilisearchService = strapi.plugin("meilisearch-plus").service("meilisearch");
+      const settings = await storeService.getStoreKey({
+        key: "meilisearch-index-settings"
+      });
+      const filterableAttributes = settings?.filterableAttributes || [];
+      const sortableAttributes = settings?.sortableAttributes || [];
+      if (!filterableAttributes.includes("_contentType")) {
+        filterableAttributes.unshift("_contentType");
+      }
+      if (!sortableAttributes.includes("_contentType")) {
+        sortableAttributes.unshift("_contentType");
+      }
+      strapi.log.info(
+        `[meilisearch-plus] Applying settings: filterable=[${filterableAttributes.join(", ")}], sortable=[${sortableAttributes.join(", ")}]`
+      );
+      await meilisearchService.updateIndexSettings({
+        settings: {
+          filterableAttributes,
+          sortableAttributes
+        }
+      });
+      ctx.body = {
+        data: {
+          message: "Settings applied to Meilisearch index successfully"
+        }
+      };
+    } catch (error) {
+      strapi.log.error("[meilisearch-plus] Error in applyIndexSettings:", error);
+      ctx.throw(500, error.message);
+    }
+  }
+});
+const controllers = {
+  credentials,
+  search,
+  contentTypes: contentTypes$1,
+  indexing,
+  indexSettings
+};
+const middlewares = {};
+const policies = {};
+const contentAPIRoutes = {
+  type: "content-api",
+  routes: [
+    {
+      method: "POST",
+      path: "/search",
+      handler: "search.search",
+      config: {
+        policies: []
+      }
+    }
+  ]
+};
+const adminAPIRoutes = {
+  type: "admin",
+  routes: [
+    {
+      method: "GET",
+      path: "/",
+      handler: "credentials.index",
+      config: {
+        auth: false
+      }
+    },
+    {
+      method: "GET",
+      path: "/credentials",
+      handler: "credentials.getCredentials",
+      config: {
+        policies: ["admin::isAuthenticatedAdmin"]
+      }
+    },
+    {
+      method: "POST",
+      path: "/credentials",
+      handler: "credentials.setCredentials",
+      config: {
+        policies: ["admin::isAuthenticatedAdmin"]
+      }
+    },
+    {
+      method: "GET",
+      path: "/test-connection",
+      handler: "credentials.testConnection",
+      config: {
+        policies: ["admin::isAuthenticatedAdmin"]
+      }
+    },
+    {
+      method: "POST",
+      path: "/search",
+      handler: "search.search",
+      config: {
+        policies: ["admin::isAuthenticatedAdmin"]
+      }
+    },
+    {
+      method: "GET",
+      path: "/index-status",
+      handler: "search.getIndexStatus",
+      config: {
+        policies: ["admin::isAuthenticatedAdmin"]
+      }
+    },
+    {
+      method: "GET",
+      path: "/configured-content-types",
+      handler: "contentTypes.getConfiguredContentTypes",
+      config: {
+        policies: ["admin::isAuthenticatedAdmin"]
+      }
+    },
+    {
+      method: "GET",
+      path: "/sync-status",
+      handler: "contentTypes.getSyncStatus",
+      config: {
+        policies: ["admin::isAuthenticatedAdmin"]
+      }
+    },
+    {
+      method: "GET",
+      path: "/sync-status/all",
+      handler: "contentTypes.getAllSyncStatus",
+      config: {
+        policies: ["admin::isAuthenticatedAdmin"]
+      }
+    },
+    {
+      method: "GET",
+      path: "/indexed-content-types",
+      handler: "contentTypes.getIndexedContentTypes",
+      config: {
+        policies: ["admin::isAuthenticatedAdmin"]
+      }
+    },
+    {
+      method: "POST",
+      path: "/indexed-content-types",
+      handler: "contentTypes.addIndexedContentType",
+      config: {
+        policies: ["admin::isAuthenticatedAdmin"]
+      }
+    },
+    {
+      method: "DELETE",
+      path: "/indexed-content-types",
+      handler: "contentTypes.removeIndexedContentType",
+      config: {
+        policies: ["admin::isAuthenticatedAdmin"]
+      }
+    },
+    {
+      method: "POST",
+      path: "/reindex",
+      handler: "indexing.reindexContentType",
+      config: {
+        policies: ["admin::isAuthenticatedAdmin"]
+      }
+    },
+    {
+      method: "POST",
+      path: "/clear-index",
+      handler: "indexing.clearIndex",
+      config: {
+        policies: ["admin::isAuthenticatedAdmin"]
+      }
+    },
+    {
+      method: "GET",
+      path: "/index-settings/content-types",
+      handler: "indexSettings.getContentTypesAndFields",
+      config: {
+        policies: ["admin::isAuthenticatedAdmin"]
+      }
+    },
+    {
+      method: "POST",
+      path: "/index-settings/save",
+      handler: "indexSettings.saveIndexSettings",
+      config: {
+        policies: ["admin::isAuthenticatedAdmin"]
+      }
+    },
+    {
+      method: "POST",
+      path: "/index-settings/apply",
+      handler: "indexSettings.applyIndexSettings",
+      config: {
+        policies: ["admin::isAuthenticatedAdmin"]
+      }
+    }
+  ]
+};
+const routes = {
+  "content-api": contentAPIRoutes,
+  admin: adminAPIRoutes
+};
+const meilisearchClient = ({ strapi }) => ({
+  createClient(config2) {
+    if (!config2.host || !config2.apiKey) {
+      strapi.log.warn("[meilisearch-plus] MeiliSearch credentials not configured");
+      return null;
+    }
+    try {
+      const client = new MeiliSearch({
+        host: config2.host,
+        apiKey: config2.apiKey
+      });
+      strapi.log.info("[meilisearch-plus] MeiliSearch client initialized");
+      return client;
+    } catch (error) {
+      strapi.log.error("[meilisearch-plus] Failed to initialize MeiliSearch client:", error);
+      return null;
+    }
+  },
+  async testConnection(client) {
+    if (!client) return false;
+    try {
+      await client.health();
+      strapi.log.info("[meilisearch-plus] MeiliSearch connection successful");
+      return true;
+    } catch (error) {
+      strapi.log.error("[meilisearch-plus] MeiliSearch connection failed:", error);
+      return false;
+    }
+  },
+  async getIndexUids(client) {
+    if (!client) return [];
+    try {
+      const response = await client.getIndexes();
+      return response.results.map((index2) => index2.uid);
+    } catch (error) {
+      strapi.log.error("[meilisearch-plus] Failed to get index UIDs:", error);
+      return [];
+    }
+  },
+  async createIndex(client, indexName, primaryKey = "id") {
+    if (!client) return null;
+    try {
+      const index2 = await client.createIndex(indexName, { primaryKey });
+      strapi.log.info(`[meilisearch-plus] Created index: ${indexName}`);
+      return index2;
+    } catch (error) {
+      strapi.log.error(`[meilisearch-plus] Failed to create index ${indexName}:`, error);
+      return null;
+    }
+  },
+  async deleteIndex(client, indexName) {
+    if (!client) return false;
+    try {
+      await client.deleteIndex(indexName);
+      strapi.log.info(`[meilisearch-plus] Deleted index: ${indexName}`);
+      return true;
+    } catch (error) {
+      strapi.log.error(`[meilisearch-plus] Failed to delete index ${indexName}:`, error);
+      return false;
+    }
+  }
+});
+const meilisearch = ({ strapi }) => ({
+  async initializeClient() {
+    const storeService = strapi.plugin("meilisearch-plus").service("store");
+    const clientService = strapi.plugin("meilisearch-plus").service("meilisearch-client");
+    const credentials2 = await storeService.getCredentials();
+    const client = clientService.createClient(credentials2);
+    if (!client) {
+      strapi.log.warn("[meilisearch-plus] No MeiliSearch client available");
+      return null;
+    }
+    const isHealthy = await clientService.testConnection(client);
+    if (!isHealthy) {
+      return null;
+    }
+    return client;
+  },
+  // Batch size for MeiliSearch operations
+  BATCH_SIZE: 1e3,
+  /**
+   * Sanitize and transform entries for MeiliSearch
+   */
+  async sanitizeEntries({
+    contentType,
+    entries
+  }) {
+    return entries.map((entry) => ({
+      _contentType: contentType,
+      id: entry.id || entry.documentId,
+      ...entry
+    }));
+  },
+  /**
+   * Add all entries for a content type to MeiliSearch (full reindex)
+   */
+  async addContentTypeInMeiliSearch({ contentType }) {
+    const client = await this.initializeClient();
+    if (!client) return [];
+    const storeService = strapi.plugin("meilisearch-plus").service("store");
+    const contentTypeService = strapi.plugin("meilisearch-plus").service("content-types");
+    const finalIndexName = await storeService.getIndexName();
+    if (!finalIndexName) {
+      strapi.log.warn("[meilisearch-plus] No index name configured");
+      return [];
+    }
+    const index2 = client.index(finalIndexName);
+    const contentTypeUid = contentTypeService.getContentTypeUid({ contentType });
+    if (!contentTypeUid) {
+      const availableUids = Object.keys(strapi.contentTypes);
+      strapi.log.error(
+        `[meilisearch-plus] Invalid content type: ${contentType}. Available UIDs: ${availableUids.join(", ")}`
+      );
+      throw new Error(`[meilisearch-plus] Invalid content type: ${contentType}`);
+    }
+    const documents = await strapi.documents(contentTypeUid).findMany({ limit: -1, status: "published" });
+    if (!documents || documents.length === 0) {
+      strapi.log.info(`[meilisearch-plus] No documents found for ${contentType}`);
+      return [];
+    }
+    const sanitized = await this.sanitizeEntries({ contentType, entries: documents });
+    let taskUids = [];
+    for (let i = 0; i < sanitized.length; i += this.BATCH_SIZE) {
+      const batch = sanitized.slice(i, i + this.BATCH_SIZE);
+      const response = await index2.addDocuments(batch, { primaryKey: "id" });
+      strapi.log.info(
+        `[meilisearch-plus] Added batch of ${batch.length} documents for ${contentType} (Task uid: ${response.taskUid})`
+      );
+      taskUids.push(response.taskUid);
+    }
+    await storeService.addIndexedContentType(contentType);
+    return taskUids;
+  },
+  /**
+   * Remove all documents for a content type from MeiliSearch
+   */
+  async emptyOrDeleteIndex({ contentType }) {
+    const client = await this.initializeClient();
+    if (!client) return;
+    const storeService = strapi.plugin("meilisearch-plus").service("store");
+    const finalIndexName = await storeService.getIndexName();
+    if (!finalIndexName) {
+      strapi.log.warn("[meilisearch-plus] No index name configured");
+      return;
+    }
+    const index2 = client.index(finalIndexName);
+    const searchResult = await index2.search("", {
+      filter: [`_contentType = "${contentType}"`],
+      limit: 1e4
+    });
+    const ids = searchResult.hits.map((hit) => hit.id);
+    if (ids.length > 0) {
+      await index2.deleteDocuments(ids);
+      strapi.log.info(`[meilisearch-plus] Deleted ${ids.length} documents for ${contentType}`);
+    }
+    await storeService.removeIndexedContentType(contentType);
+  },
+  /**
+   * Update (reindex) all entries for a content type
+   */
+  async updateContentTypeInMeiliSearch({ contentType }) {
+    await this.emptyOrDeleteIndex({ contentType });
+    return this.addContentTypeInMeiliSearch({ contentType });
+  },
+  async deleteDocument({ contentType, documentId, indexName = null }) {
+    const client = await this.initializeClient();
+    if (!client) return;
+    try {
+      const storeService = strapi.plugin("meilisearch-plus").service("store");
+      const finalIndexName = indexName || await storeService.getIndexName();
+      if (!finalIndexName) {
+        strapi.log.warn("[meilisearch-plus] No index name configured");
+        return;
+      }
+      const index2 = client.index(finalIndexName);
+      await index2.deleteDocument(documentId);
+      strapi.log.debug(`[meilisearch-plus] Deleted document ${documentId} from ${finalIndexName}`);
+    } catch (error) {
+      strapi.log.error("[meilisearch-plus] Failed to delete document:", error);
+    }
+  },
+  async deleteAllDocuments({ contentType, indexName = null }) {
+    const client = await this.initializeClient();
+    if (!client) return;
+    try {
+      const storeService = strapi.plugin("meilisearch-plus").service("store");
+      const finalIndexName = indexName || await storeService.getIndexName();
+      if (!finalIndexName) {
+        strapi.log.warn("[meilisearch-plus] No index name configured");
+        return;
+      }
+      const index2 = client.index(finalIndexName);
+      if (contentType) {
+        const searchResult = await index2.search("", {
+          filter: [`_contentType = "${contentType}"`],
+          limit: 1e4
+        });
+        const ids = searchResult.hits.map((hit) => hit.id);
+        if (ids.length > 0) {
+          await index2.deleteDocuments(ids);
+          strapi.log.info(`[meilisearch-plus] Deleted ${ids.length} documents for ${contentType}`);
+        } else {
+          strapi.log.info(`[meilisearch-plus] No documents found for ${contentType} to delete.`);
+        }
+      } else {
+        await index2.deleteAllDocuments();
+        strapi.log.info(`[meilisearch-plus] Deleted all documents in index`);
+      }
+    } catch (error) {
+      strapi.log.error("[meilisearch-plus] Failed to delete all documents:", error);
+    }
+  },
+  async search({ query, indexName = null, filters = null, limit = 10, offset = 0 }) {
+    const client = await this.initializeClient();
+    if (!client) return null;
+    try {
+      const storeService = strapi.plugin("meilisearch-plus").service("store");
+      const finalIndexName = indexName || await storeService.getIndexName();
+      if (!finalIndexName) {
+        strapi.log.warn("[meilisearch-plus] No index name configured");
+        return null;
+      }
+      const index2 = client.index(finalIndexName);
+      const results = await index2.search(query, {
+        filter: filters,
+        limit,
+        offset
+      });
+      return results;
+    } catch (error) {
+      strapi.log.error("[meilisearch-plus] Search failed:", error);
+      return null;
+    }
+  },
+  async getIndexSettings({ indexName = null }) {
+    const client = await this.initializeClient();
+    if (!client) return null;
+    try {
+      const storeService = strapi.plugin("meilisearch-plus").service("store");
+      const finalIndexName = indexName || await storeService.getIndexName();
+      if (!finalIndexName) {
+        return null;
+      }
+      const index2 = client.index(finalIndexName);
+      const settings = await index2.getSettings();
+      return settings;
+    } catch (error) {
+      strapi.log.error("[meilisearch-plus] Failed to get index settings:", error);
+      return null;
+    }
+  },
+  async updateIndexSettings({ indexName = null, settings }) {
+    const client = await this.initializeClient();
+    if (!client) return false;
+    try {
+      const storeService = strapi.plugin("meilisearch-plus").service("store");
+      const finalIndexName = indexName || await storeService.getIndexName();
+      if (!finalIndexName) {
+        return false;
+      }
+      const index2 = client.index(finalIndexName);
+      await index2.updateSettings(settings);
+      strapi.log.info(`[meilisearch-plus] Updated settings for index ${finalIndexName}`);
+      return true;
+    } catch (error) {
+      strapi.log.error("[meilisearch-plus] Failed to update index settings:", error);
+      return false;
+    }
+  },
+  async ensureContentTypeFilterable({ indexName = null }) {
+    const client = await this.initializeClient();
+    if (!client) return false;
+    try {
+      const storeService = strapi.plugin("meilisearch-plus").service("store");
+      const finalIndexName = indexName || await storeService.getIndexName();
+      if (!finalIndexName) return false;
+      const index2 = client.index(finalIndexName);
+      const settings = await index2.getSettings();
+      const filterable = settings.filterableAttributes || [];
+      if (!filterable.includes("_contentType")) {
+        filterable.push("_contentType");
+        await index2.updateSettings({ filterableAttributes: filterable });
+        strapi.log.info(
+          `[meilisearch-plus] Added _contentType to filterableAttributes for index ${finalIndexName}`
+        );
+      }
+      return true;
+    } catch (error) {
+      strapi.log.error("[meilisearch-plus] Failed to ensure _contentType is filterable:", error);
+      return false;
+    }
+  },
+  async syncIndexedCollections() {
+    const storeService = strapi.plugin("meilisearch-plus").service("store");
+    const client = await this.initializeClient();
+    if (!client) {
+      strapi.log.debug("[meilisearch-plus] No MeiliSearch client available for sync");
+      return;
+    }
+    try {
+      const indexName = await storeService.getIndexName();
+      if (!indexName) {
+        strapi.log.debug("[meilisearch-plus] No index name configured for sync");
+        return;
+      }
+      const indexedContentTypes = await storeService.getIndexedContentTypes();
+      if (!indexedContentTypes || indexedContentTypes.length === 0) {
+        return;
+      }
+      const index2 = client.index(indexName);
+      for (const contentType of indexedContentTypes) {
+        try {
+          const searchResult = await index2.search("", {
+            filter: [`_contentType = "${contentType}"`],
+            limit: 0
+          });
+          if (searchResult.estimatedTotalHits === 0) {
+            strapi.log.debug(
+              `[meilisearch-plus] No documents found for ${contentType}, removing from indexed list`
+            );
+            await storeService.removeIndexedContentType(contentType);
+          }
+        } catch (e) {
+          strapi.log.debug(
+            `[meilisearch-plus] Could not search for ${contentType} during sync: ${e.message}`
+          );
+          continue;
+        }
+      }
+      strapi.log.info("[meilisearch-plus] Synced indexed collections");
+    } catch (error) {
+      strapi.log.error("[meilisearch-plus] Failed to sync indexed collections:", error);
+    }
+  }
+});
+const store = ({ strapi }) => {
+  const strapiStore = strapi.store({
+    type: "plugin",
+    name: "meilisearch-plus"
+  });
+  return {
+    async getApiKey() {
+      const credentials2 = await strapiStore.get({ key: "credentials" });
+      return credentials2?.apiKey || "";
+    },
+    async setApiKey(apiKey) {
+      const credentials2 = await strapiStore.get({ key: "credentials" });
+      await strapiStore.set({ key: "credentials", value: { ...credentials2, apiKey } });
+    },
+    async getHost() {
+      const credentials2 = await strapiStore.get({ key: "credentials" });
+      return credentials2?.host || "";
+    },
+    async setHost(host) {
+      const credentials2 = await strapiStore.get({ key: "credentials" });
+      await strapiStore.set({ key: "credentials", value: { ...credentials2, host } });
+    },
+    async getIndexName() {
+      const credentials2 = await strapiStore.get({ key: "credentials" });
+      return credentials2?.indexName || "";
+    },
+    async setIndexName(indexName) {
+      const credentials2 = await strapiStore.get({ key: "credentials" });
+      await strapiStore.set({ key: "credentials", value: { ...credentials2, indexName } });
+    },
+    async getCredentials() {
+      const data = await strapiStore.get({ key: "credentials" });
+      let host = data?.host || "";
+      let apiKey = data?.apiKey || "";
+      let indexName = data?.indexName || "";
+      if (!host || !apiKey) {
+        try {
+          const pluginConfig = strapi.config.get("plugin::meilisearch-plus");
+          if (pluginConfig) {
+            if (!host && pluginConfig.host) {
+              host = pluginConfig.host;
+            }
+            if (!apiKey && pluginConfig.apiKey) {
+              apiKey = pluginConfig.apiKey;
+            }
+            if (!indexName && pluginConfig.post?.indexName) {
+              indexName = pluginConfig.post.indexName;
+            }
+          }
+        } catch (error) {
+          strapi.log.debug("[meilisearch-plus] Could not retrieve plugin config");
+        }
+      }
+      return { host, apiKey, indexName };
+    },
+    async syncCredentials() {
+      const pluginConfig = strapi.config.get("plugin::meilisearch-plus");
+      let apiKey = "";
+      let host = "";
+      if (pluginConfig) {
+        apiKey = pluginConfig.apiKey || "";
+        host = pluginConfig.host || "";
+      }
+      const existingApiKey = await this.getApiKey();
+      const existingHost = await this.getHost();
+      if (!existingApiKey && apiKey) {
+        await this.setApiKey(apiKey);
+      }
+      if (!existingHost && host) {
+        await this.setHost(host);
+      }
+      return { apiKey, host };
+    },
+    async setCredentials(credentials2) {
+      await strapiStore.set({ key: "credentials", value: credentials2 });
+      strapi.log.info("[meilisearch-plus] Credentials updated");
+    },
+    async getIndexedContentTypes() {
+      const data = await strapiStore.get({ key: "indexed-content-types" });
+      return data?.contentTypes || [];
+    },
+    async setIndexedContentTypes(contentTypes2) {
+      await strapiStore.set({ key: "indexed-content-types", value: { contentTypes: contentTypes2 } });
+    },
+    async addIndexedContentType(contentType) {
+      const contentTypes2 = await this.getIndexedContentTypes();
+      console.log("Current indexed content types:", contentTypes2);
+      console.log("Adding content type:", contentType);
+      if (!contentTypes2.includes(contentType)) {
+        contentTypes2.push(contentType);
+        await this.setIndexedContentTypes(contentTypes2);
+      }
+    },
+    async removeIndexedContentType(contentType) {
+      const contentTypes2 = await this.getIndexedContentTypes();
+      const filtered = contentTypes2.filter((ct) => ct !== contentType);
+      await this.setIndexedContentTypes(filtered);
+    },
+    async getListenedContentTypes() {
+      const data = await strapiStore.get({ key: "listened-content-types" });
+      return data?.contentTypes || [];
+    },
+    async setListenedContentTypes(contentTypes2) {
+      await strapiStore.set({ key: "listened-content-types", value: { contentTypes: contentTypes2 } });
+    },
+    async getStoreKey(options) {
+      const data = await strapiStore.get({ key: options.key });
+      return data;
+    },
+    async setStoreKey(options) {
+      await strapiStore.set({ key: options.key, value: options.value });
+    }
+  };
+};
+const lifecycle = ({ strapi }) => ({
+  async subscribeContentType({ contentType }) {
+    const meilisearchService = strapi.plugin("meilisearch-plus").service("meilisearch");
+    strapi.plugin("meilisearch-plus").service("store");
+    strapi.db.lifecycles.subscribe({
+      models: [contentType],
+      async afterCreate(event) {
+        const { result } = event;
+        try {
+          await meilisearchService.indexDocument({ contentType, document: result });
+          strapi.log.debug(`[meilisearch-plus] Indexed document for ${contentType}`);
+        } catch (error) {
+          strapi.log.error(
+            `[meilisearch-plus] Failed to index document for ${contentType}:`,
+            error
+          );
+        }
+      }
+    });
+    strapi.db.lifecycles.subscribe({
+      models: [contentType],
+      async afterUpdate(event) {
+        const { result } = event;
+        try {
+          await meilisearchService.indexDocument({ contentType, document: result });
+          strapi.log.debug(`[meilisearch-plus] Updated indexed document for ${contentType}`);
+        } catch (error) {
+          strapi.log.error(
+            `[meilisearch-plus] Failed to update indexed document for ${contentType}:`,
+            error
+          );
+        }
+      }
+    });
+    strapi.db.lifecycles.subscribe({
+      models: [contentType],
+      async afterDelete(event) {
+        const { result } = event;
+        try {
+          await meilisearchService.deleteDocument({ contentType, documentId: result.id });
+          strapi.log.debug(`[meilisearch-plus] Deleted indexed document for ${contentType}`);
+        } catch (error) {
+          strapi.log.error(
+            `[meilisearch-plus] Failed to delete indexed document for ${contentType}:`,
+            error
+          );
+        }
+      }
+    });
+    strapi.log.info(`[meilisearch-plus] Subscribed to lifecycle events for ${contentType}`);
+  },
+  async unsubscribeContentType({ contentType }) {
+    strapi.log.info(`[meilisearch-plus] Unsubscribed from lifecycle events for ${contentType}`);
+  }
+});
+const contentTypes = ({ strapi }) => ({
+  /**
+   * Get the content type UID from either a UID or a model name
+   */
+  getContentTypeUid({ contentType }) {
+    const contentTypes2 = strapi.contentTypes;
+    const contentTypeUids = Object.keys(contentTypes2);
+    strapi.log.debug(`[meilisearch-plus] getContentTypeUid: Looking for "${contentType}"`);
+    strapi.log.debug(`[meilisearch-plus] Available UIDs:`, contentTypeUids);
+    if (contentTypeUids.includes(contentType)) {
+      strapi.log.debug(`[meilisearch-plus] Found as UID: ${contentType}`);
+      return contentType;
+    }
+    const withPrefix = `api::${contentType}.${contentType}`;
+    if (contentTypeUids.includes(withPrefix)) {
+      strapi.log.debug(`[meilisearch-plus] Found with prefix: ${withPrefix}`);
+      return withPrefix;
+    }
+    const found = contentTypeUids.find((uid) => {
+      const ctConfig = contentTypes2[uid];
+      const matches = ctConfig.modelName === contentType;
+      if (matches) {
+        strapi.log.debug(`[meilisearch-plus] Found by modelName match: ${uid}`);
+      }
+      return matches;
+    });
+    if (!found) {
+      const fallback = contentTypeUids.find((uid) => uid.split(".").pop() === contentType);
+      if (fallback) {
+        strapi.log.debug(`[meilisearch-plus] Fallback match by last segment: ${fallback}`);
+        return fallback;
+      }
+    }
+    if (!found) {
+      strapi.log.warn(
+        `[meilisearch-plus] Could not find UID for "${contentType}". Available:`,
+        contentTypeUids
+      );
+    }
+    return found;
+  },
+  /**
+   * Get the collection/model name from a content type UID or name
+   */
+  getCollectionName({ contentType }) {
+    const contentTypes2 = strapi.contentTypes;
+    const contentTypeUids = Object.keys(contentTypes2);
+    if (contentTypeUids.includes(contentType)) {
+      return contentTypes2[contentType].modelName;
+    }
+    return contentType;
+  },
+  /**
+   * Count published documents in a content type
+   */
+  async getDocumentCount({
+    contentType,
+    filters = {},
+    status = "published"
+  }) {
+    const contentTypeUid = this.getContentTypeUid({ contentType });
+    if (!contentTypeUid) {
+      const contentTypes2 = strapi.contentTypes;
+      const availableUids = Object.keys(contentTypes2);
+      const apiContentTypes = availableUids.filter((uid) => uid.startsWith("api::"));
+      strapi.log.warn(
+        `[meilisearch-plus] Could not find UID for "${contentType}". Available API types:`,
+        apiContentTypes
+      );
+      return 0;
+    }
+    try {
+      const count = await strapi.documents(contentTypeUid).count({
+        filters,
+        status
+      });
+      return count || 0;
+    } catch (error) {
+      strapi.log.warn(`[meilisearch-plus] getDocumentCount error for ${contentType}:`, error);
+      return 0;
+    }
+  },
+  /**
+   * Count indexed documents in MeiliSearch for a content type
+   */
+  async getIndexedDocumentCount({
+    contentType,
+    indexName = null
+  }) {
+    try {
+      const meilisearchService = strapi.plugin("meilisearch-plus").service("meilisearch");
+      const storeService = strapi.plugin("meilisearch-plus").service("store");
+      const finalIndexName = indexName || await storeService.getIndexName();
+      if (!finalIndexName) {
+        strapi.log.debug("[meilisearch-plus] No index name configured");
+        return 0;
+      }
+      const client = await meilisearchService.initializeClient();
+      if (!client) {
+        return 0;
+      }
+      const index2 = client.index(finalIndexName);
+      const result = await index2.search("", {
+        filter: [`_contentType = "${contentType}"`],
+        limit: 0
+      });
+      return result.estimatedTotalHits || 0;
+    } catch (error) {
+      if (error?.message?.includes("not found")) {
+        strapi.log.debug(
+          `[meilisearch-plus] Index not found for ${contentType} (this is normal on first setup)`
+        );
+        return 0;
+      }
+      strapi.log.warn(
+        `[meilisearch-plus] getIndexedDocumentCount error for ${contentType}:`,
+        error
+      );
+      return 0;
+    }
+  },
+  /**
+   * Get sync status for a content type
+   * Returns: total, indexed, syncPercentage
+   */
+  async getSyncStatus({ contentType }) {
+    const total = await this.getDocumentCount({ contentType });
+    const indexed = await this.getIndexedDocumentCount({ contentType });
+    const syncPercentage = total === 0 ? 0 : Math.round(indexed / total * 100);
+    const isSynced = total === indexed && total > 0;
+    return {
+      total,
+      indexed,
+      syncPercentage,
+      isSynced
+    };
+  },
+  /**
+   * Get sync status for multiple content types
+   */
+  async getSyncStatusForMultiple({ contentTypes: contentTypes2 }) {
+    const results = {};
+    for (const contentType of contentTypes2) {
+      results[contentType] = await this.getSyncStatus({ contentType });
+    }
+    return results;
+  }
+});
+const services = {
+  "meilisearch-client": meilisearchClient,
+  meilisearch,
+  store,
+  lifecycle,
+  "content-types": contentTypes
+};
+const index = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes: contentTypes$2,
+  policies,
+  middlewares
+};
+export {
+  index as default
+};