strapi-plugin-meilisearch-plus 0.0.1

package/README.md

@@ -0,0 +1,266 @@
+# MeiliSearch Plus Plugin
+
+A comprehensive MeiliSearch integration plugin for Strapi v5 that enables full-text search capabilities for your content.
+
+### Features
+
+#### Server-Side
+
+- **Credential Management**: Securely store MeiliSearch host and API key
+- **Automatic Indexing**: Automatically index documents on create, update, and delete
+- **Published Documents Only**: Only published documents are indexed (draft documents are excluded)
+- **Content Type Management**: Choose which content types to index
+- **Manual Indexing**: Trigger reindexing of specific content types without affecting others
+- **Safe Reindex**: Reindex operations only affect the specified content type
+- **Search API**: Full-text search with filters, pagination, and sorting
+- **Connection Testing**: Verify MeiliSearch connection before operations
+- **Index Status**: Monitor index health and sync status with display names
+- **Content Type Display Names**: Full content type metadata with human-readable names
+
+### Admin API Routes
+
+#### Credentials Management
+
+- `GET /meilisearch-plus/credentials` - Get current credentials
+- `POST /meilisearch-plus/credentials` - Set credentials (host, apiKey, indexName)
+- `GET /meilisearch-plus/test-connection` - Test MeiliSearch connection
+
+#### Search Operations
+
+- `POST /meilisearch-plus/search` - Execute search query
+  - Body: `{ query, filters?, limit?, offset? }`
+- `GET /meilisearch-plus/index-status` - Get index status and statistics
+
+#### Content Type Management
+
+- `GET /meilisearch-plus/sync-status/all` - Get all configured content types with sync status
+  - Returns: `{ contentType, displayName, isIndexed, total, indexed, syncPercentage, isSynced }`
+- `GET /meilisearch-plus/indexed-content-types` - List indexed content types
+- `POST /meilisearch-plus/indexed-content-types` - Add content type to index
+  - Body: `{ contentType }`
+- `DELETE /meilisearch-plus/indexed-content-types` - Remove content type from index and MeiliSearch
+
+#### Manual Indexing
+
+- `POST /meilisearch-plus/reindex` - Reindex documents for a specific content type
+  - Body: `{ contentType }` - Only reindexes the specified content type
+- `POST /meilisearch-plus/clear-index` - Clear indexed documents for a content type
+  - Body: `{ contentType }` - Only clears the specified content type
+
+### Content API Routes (Public)
+
+- `POST /api/plugins/meilisearch-plus/search` - Public search endpoint
+  - Body: `{ query, filters?, limit?, offset? }`
+
+## Architecture
+
+### Services
+
+#### `meilisearch-client.ts`
+
+Factory service for creating and managing MeiliSearch client instances.
+
+- `createClient(credentials)` - Create authenticated client
+- `testConnection(client)` - Verify connection health
+- `getIndexUids(client)` - List all indexes
+- `createIndex(client, indexName)` - Create new index
+- `deleteIndex(client, indexName)` - Delete index
+
+#### `store.ts`
+
+Persistent storage for credentials and configuration using Strapi's store API.
+
+- `getCredentials()` / `setCredentials()`
+- `getApiKey()` / `setApiKey()`
+- `getHost()` / `setHost()`
+- `getIndexName()` / `setIndexName()`
+- `getIndexedContentTypes()` / `setIndexedContentTypes()`
+- `addIndexedContentType()` / `removeIndexedContentType()`
+
+#### `meilisearch.ts`
+
+Core indexing and search service.
+
+- `indexDocument()` - Index single document
+- `indexDocuments()` - Bulk index documents
+- `deleteDocument()` - Remove document from index
+- `deleteAllDocuments()` - Clear all documents
+- `search()` - Search with filters and pagination
+- `getIndexSettings()` / `updateIndexSettings()`
+
+#### `lifecycle.ts`
+
+Lifecycle hook subscriptions for automatic indexing.
+
+- `subscribeContentType(contentType)` - Listen to create/update/delete events
+- `unsubscribeContentType(contentType)` - Stop listening (metadata only)
+
+### Controllers
+
+#### `credentials.ts`
+
+Admin endpoints for managing MeiliSearch credentials and connections.
+
+#### `search.ts`
+
+Search functionality with index status monitoring.
+
+#### `content-types.ts`
+
+Manage which content types are indexed.
+
+#### `indexing.ts`
+
+Manual indexing operations (reindex, clear).
+
+## Admin Panel
+
+The plugin provides a dedicated admin interface in the Strapi Settings menu with two sections:
+
+### Settings Page
+
+Access the plugin settings at **Settings > MeiliSearch Plus**:
+
+#### Credentials Tab
+
+Configure MeiliSearch connection details:
+
+- **MeiliSearch URL** - The URL where MeiliSearch is running (e.g., `http://localhost:7700`)
+- **API Key** - API key with permission to create indexes (master key recommended)
+- **Index Name** - Name of the MeiliSearch index to use for this installation
+
+Features:
+
+- Test connection button to verify credentials
+- Security warning about API key exposure
+- Save configuration
+
+#### Index Settings Tab
+
+Configure which fields are searchable and sortable per content type:
+
+- **Max Total Hits** - Maximum number of documents returned by MeiliSearch (default: 1000)
+- **Filterable Attributes** - Select which fields can be used as filters in search queries
+- **Sortable Attributes** - Select which fields can be sorted in search results
+- **Mandatory Field**: `_contentType` is always included (required for document categorization)
+- Organize by content type using tabbed interface
+- Human-readable field names (converted from snake_case)
+
+### Collections Tab
+
+Monitor indexed content types in the main plugin view:
+
+- View all configured content types with display names
+- Check indexing status (complete/in-progress)
+- See database count vs indexed documents
+- Toggle content types on/off for indexing
+- Update index (sync without full rebuild)
+- Reindex individual content types (only affects the selected type)
+- See hooks status (automatic sync enabled/disabled)
+
+## Configuration
+
+The plugin is enabled by default in `apps/cms/config/plugins.ts`:
+
+```typescript
+'meilisearch-plus': {
+  enabled: true,
+  resolve: './src/plugins/meilisearch-plus',
+},
+```
+
+## Environment Variables
+
+Set these in your `.env` file:
+
+```
+MEILISEARCH_HOST=http://localhost:7700
+MEILISEARCH_API_KEY=your-api-key
+MEILISEARCH_INDEX_NAME=your-index-name
+```
+
+## UID Mapping and Content Type Handling
+
+Content types are configured using short names in the plugin config (e.g., `page`, `job`) and are mapped to full UIDs:
+
+```typescript
+// Config uses short names
+'meilisearch-plus': {
+  page: { /* config */},
+  job: { /* config */},
+}
+
+// Internally mapped to full UIDs
+api::page.page
+api::job.job
+```
+
+The `/sync-status/all` endpoint returns:
+
+```json
+{
+  "contentType": "api::page.page",
+  "displayName": "Pagina",
+  "isIndexed": true,
+  "total": 18,
+  "indexed": 18,
+  "syncPercentage": 100,
+  "isSynced": true
+}
+```
+
+## Key Implementation Details
+
+### Content Type Identification
+
+The plugin uses full content type UIDs throughout the application (e.g., `api::page.page`):
+
+- UIDs are mapped from plugin configuration short names
+- Display names are fetched from Strapi content type schema
+- All API responses include both UID and displayName for clarity
+
+### Document Indexing
+
+- **Status Filter**: Only `published` documents are indexed (draft documents are excluded)
+- **Content Type Field**: The `_contentType` field is automatically added to all documents for categorization
+- **Batch Processing**: Documents are indexed in batches of 1000
+- **Safe Deletion**: When toggling off a content type, all its documents are removed from MeiliSearch
+
+### Reindex Operations
+
+- **Content Type Scoped**: Reindex and clear operations only affect the specified content type
+- **No Cross-Type Interference**: Toggling or reindexing one type doesn't affect others
+- **Full Rebuild**: Reindex performs a complete delete and re-add cycle for the specific type
+
+### Attribute Settings
+
+- **Mandatory Fields**: `_contentType` is always included in filterable and sortable attributes (required for document lookup)
+- **Field Name Formatting**: Field names are converted to human-readable format in the UI (e.g., `publishedAt` → "Published At")
+- **Per-Content-Type Config**: Settings are merged across content types to create a unified index configuration
+
+### Database & Storage
+
+The plugin uses Strapi's store API to persist:
+
+- MeiliSearch credentials (host, API key, index name)
+- Indexed content types list
+- Index settings (filterable/sortable attributes, max total hits)
+- Lifecycle subscriptions for automatic indexing
+
+## Error Handling
+
+All services include comprehensive error handling with logging:
+
+- Connection errors are logged but don't block startup
+- Document indexing failures are logged but don't break transactions
+- Missing credentials/index names are handled gracefully
+- All operations have timeout protection
+- Reindex and clear operations safely handle already-deleted documents
+
+## Type Safety
+
+The plugin is fully written in TypeScript with:
+
+- Strict type checking
+- Comprehensive JSDoc comments
+- Service interfaces for IDE autocompletion

package/dist/_chunks/CollectionsTable-DhFoYbHi.mjs

@@ -0,0 +1,376 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { memo, useState, useEffect } from "react";
+import { Flex, Loader, Box, Typography, Badge, Table, Tr, Td, Tbody, Checkbox, Button } from "@strapi/design-system";
+import { useFetchClient, useNotification } from "@strapi/strapi/admin";
+import { Check } from "@strapi/icons";
+import { u as useI18n } from "./useI18n-RYsv52c9.mjs";
+import { p as pluginId } from "./index-DgpT8G3z.mjs";
+const RefreshIcon = ({ size = 16, color = "currentColor" }) => /* @__PURE__ */ jsxs(
+  "svg",
+  {
+    width: size,
+    height: size,
+    viewBox: "0 0 24 24",
+    fill: "none",
+    stroke: color,
+    strokeWidth: "2",
+    strokeLinecap: "round",
+    strokeLinejoin: "round",
+    children: [
+      /* @__PURE__ */ jsx("polyline", { points: "23 4 23 10 17 10" }),
+      /* @__PURE__ */ jsx("polyline", { points: "1 20 1 14 7 14" }),
+      /* @__PURE__ */ jsx("path", { d: "M3.51 9a9 9 0 0 1 14.85-3.36M20.49 15a9 9 0 0 1-14.85 3.36" })
+    ]
+  }
+);
+const XIcon = ({ size = 16, color = "currentColor" }) => /* @__PURE__ */ jsxs(
+  "svg",
+  {
+    width: size,
+    height: size,
+    viewBox: "0 0 24 24",
+    fill: "none",
+    stroke: color,
+    strokeWidth: "2",
+    strokeLinecap: "round",
+    strokeLinejoin: "round",
+    children: [
+      /* @__PURE__ */ jsx("line", { x1: "18", y1: "6", x2: "6", y2: "18" }),
+      /* @__PURE__ */ jsx("line", { x1: "6", y1: "6", x2: "18", y2: "18" })
+    ]
+  }
+);
+const DangerIcon = ({ size = 16, color = "currentColor" }) => /* @__PURE__ */ jsx(
+  "svg",
+  {
+    width: size,
+    height: size,
+    viewBox: "0 0 24 24",
+    fill: "none",
+    stroke: color,
+    strokeWidth: "2",
+    strokeLinecap: "round",
+    strokeLinejoin: "round",
+    children: /* @__PURE__ */ jsx("polygon", { points: "12 2 22 20 2 20" })
+  }
+);
+const CollectionsTable = memo(() => {
+  const { i18n } = useI18n();
+  const { get, post, del } = useFetchClient();
+  const { toggleNotification } = useNotification();
+  const [contentTypes, setContentTypes] = useState([]);
+  const [isLoading, setIsLoading] = useState(true);
+  const [loadingState, setLoadingState] = useState({});
+  const [syncData, setSyncData] = useState({});
+  useEffect(() => {
+    loadContentTypes();
+  }, [get]);
+  const loadContentTypes = async () => {
+    setIsLoading(true);
+    try {
+      const syncResponse = await get(`/${pluginId}/sync-status/all`);
+      const syncStatuses = syncResponse.data?.data || [];
+      console.log("Sync statuses from API:", syncStatuses);
+      const configuredUids = syncStatuses.map((item) => item.contentType);
+      console.log("Configured content types from API:", configuredUids);
+      const allContentTypes = strapi.contentTypes;
+      const syncMap = {};
+      const types = syncStatuses.map((item) => {
+        syncMap[item.contentType] = {
+          total: item.total || 0,
+          indexed: item.indexed || 0,
+          syncPercentage: item.syncPercentage || 0,
+          isSynced: item.isSynced || false,
+          isIndexed: item.isIndexed || false
+        };
+        return {
+          name: item.displayName || item.contentType,
+          uid: item.contentType,
+          displayName: item.displayName || item.contentType,
+          isIndexed: item.isIndexed || false,
+          total: item.total || 0,
+          indexed: item.indexed || 0,
+          syncPercentage: item.syncPercentage || 0,
+          isSynced: item.isSynced || false
+        };
+      });
+      setSyncData(syncMap);
+      setContentTypes(types);
+    } catch (error) {
+      console.error("[meilisearch-plus] Failed to load content types:", error);
+      toggleNotification({
+        type: "warning",
+        message: "Failed to load sync status"
+      });
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  const handleToggle = async (name) => {
+    console.log(contentTypes);
+    const currentContentType = contentTypes.find((ct) => ct.name === name || ct.uid === name);
+    if (!currentContentType) return;
+    const shouldAddIndex = !currentContentType.isIndexed;
+    console.log(`[meilisearch-plus] Toggling ${name} to ${shouldAddIndex}`);
+    setLoadingState((prev) => ({ ...prev, [name]: true }));
+    try {
+      const contentTypeUid = currentContentType?.uid || name;
+      if (shouldAddIndex) {
+        console.log(`[meilisearch-plus] POST to /${pluginId}/indexed-content-types`);
+        const response = await post(`/${pluginId}/indexed-content-types`, {
+          contentType: contentTypeUid
+        });
+        console.log("[meilisearch-plus] POST response:", response);
+        console.log(`[meilisearch-plus] Reindexing ${contentTypeUid} after adding to index`);
+        await post(`/${pluginId}/reindex`, { contentType: contentTypeUid });
+        console.log(`[meilisearch-plus] Reindex complete for ${contentTypeUid}`);
+      } else {
+        console.log(
+          `[meilisearch-plus] DELETE to /${pluginId}/indexed-content-types?contentType=${contentTypeUid}`
+        );
+        const response = await del(
+          `/${pluginId}/indexed-content-types?contentType=${contentTypeUid}`
+        );
+        console.log("[meilisearch-plus] DELETE response:", response);
+      }
+      setContentTypes(
+        (prev) => prev.map((ct) => ct.name === name ? { ...ct, isIndexed: shouldAddIndex } : ct)
+      );
+      toggleNotification({
+        type: "success",
+        message: shouldAddIndex ? `${name} added to index` : `${name} removed from index`
+      });
+      await loadContentTypes();
+    } catch (error) {
+      console.error(`[meilisearch-plus] Failed to toggle ${name}:`, error);
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      console.error("[meilisearch-plus] Error details:", errorMessage);
+      toggleNotification({
+        type: "warning",
+        message: `Failed to update ${name}: ${errorMessage}`
+      });
+    } finally {
+      setLoadingState((prev) => ({ ...prev, [name]: false }));
+    }
+  };
+  const handleUpdate = async (contentType) => {
+    console.log(`[meilisearch-plus] Updating ${contentType}`);
+    setLoadingState((prev) => ({ ...prev, [contentType]: true }));
+    try {
+      const ct = contentTypes.find((ct2) => ct2.name === contentType || ct2.uid === contentType);
+      const contentTypeUid = ct?.uid || contentType;
+      const response = await post(`/${pluginId}/reindex`, { contentType: contentTypeUid });
+      console.log("[meilisearch-plus] Update response:", response);
+      toggleNotification({
+        type: "success",
+        message: `${contentType} index updated`
+      });
+      await loadContentTypes();
+    } catch (error) {
+      console.error(`[meilisearch-plus] Failed to update ${contentType}:`, error);
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      toggleNotification({
+        type: "warning",
+        message: `Failed to update ${contentType}: ${errorMessage}`
+      });
+    } finally {
+      setLoadingState((prev) => ({ ...prev, [contentType]: false }));
+    }
+  };
+  const handleReindex = async (contentType) => {
+    console.log(`[meilisearch-plus] Reindexing ${contentType}`);
+    setLoadingState((prev) => ({ ...prev, [contentType]: true }));
+    try {
+      const ct = contentTypes.find((ct2) => ct2.name === contentType || ct2.uid === contentType);
+      const contentTypeUid = ct?.uid || contentType;
+      await post(`/${pluginId}/clear-index`, { contentType: contentTypeUid });
+      console.log("[meilisearch-plus] Index cleared for", contentTypeUid);
+      const response = await post(`/${pluginId}/reindex`, { contentType: contentTypeUid });
+      console.log("[meilisearch-plus] Reindex response:", response);
+      toggleNotification({
+        type: "success",
+        message: `${contentType} index reindexed`
+      });
+      await loadContentTypes();
+    } catch (error) {
+      console.error(`[meilisearch-plus] Failed to reindex ${contentType}:`, error);
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      toggleNotification({
+        type: "warning",
+        message: `Failed to reindex ${contentType}: ${errorMessage}`
+      });
+    } finally {
+      setLoadingState((prev) => ({ ...prev, [contentType]: false }));
+    }
+  };
+  if (isLoading) {
+    return /* @__PURE__ */ jsx(Flex, { justifyContent: "center", alignItems: "center", minHeight: "400px", children: /* @__PURE__ */ jsx(Loader, {}) });
+  }
+  const COL_COUNT = 8;
+  const ROW_COUNT = Math.max(6, contentTypes.length);
+  return /* @__PURE__ */ jsxs(Box, { background: "neutral100", padding: 4, children: [
+    /* @__PURE__ */ jsxs(Box, { padding: 6, marginBottom: 6, background: "neutral0", hasRadius: true, children: [
+      /* @__PURE__ */ jsx(Typography, { variant: "beta", marginBottom: 6, paddingBottom: 4, children: i18n("plugin.legend.title", "Legend") }),
+      /* @__PURE__ */ jsxs(
+        Flex,
+        {
+          direction: "column",
+          alignItems: "flex-start",
+          justifyContent: "between",
+          gap: 6,
+          style: { width: "100%" },
+          children: [
+            /* @__PURE__ */ jsxs(Flex, { alignItems: "flex-start", justifyContent: "between", gap: 6, style: { width: "100%" }, children: [
+              /* @__PURE__ */ jsxs(Box, { flex: 1, children: [
+                /* @__PURE__ */ jsx(Typography, { variant: "sigma", textColor: "neutral600", marginBottom: 3, children: i18n("plugin.legend.in-meilisearch", "IN MEILISEARCH") }),
+                /* @__PURE__ */ jsxs(Flex, { direction: "column", alignItems: "flex-start", gap: 3, paddingTop: 2, children: [
+                  /* @__PURE__ */ jsxs(Flex, { gap: 3, alignItems: "flex-start", children: [
+                    /* @__PURE__ */ jsx(Badge, { background: "success600", textColor: "neutral0", children: /* @__PURE__ */ jsx(Check, {}) }),
+                    /* @__PURE__ */ jsx(Typography, { size: "sm", children: i18n("plugin.legend.indexed", "Content type is indexed") })
+                  ] }),
+                  /* @__PURE__ */ jsxs(Flex, { gap: 3, alignItems: "flex-start", children: [
+                    /* @__PURE__ */ jsx(Badge, { background: "neutral900", textColor: "neutral0", children: /* @__PURE__ */ jsx(XIcon, { size: 16, color: "white" }) }),
+                    /* @__PURE__ */ jsx(Typography, { size: "sm", children: i18n("plugin.legend.not-indexed", "Content type is not indexed") })
+                  ] })
+                ] })
+              ] }),
+              /* @__PURE__ */ jsxs(Box, { flex: 1, children: [
+                /* @__PURE__ */ jsx(Typography, { variant: "sigma", textColor: "neutral600", marginBottom: 3, children: i18n("plugin.legend.indexing-status", "INDEXING STATUS") }),
+                /* @__PURE__ */ jsxs(Flex, { direction: "column", gap: 3, alignItems: "flex-start", paddingTop: 2, children: [
+                  /* @__PURE__ */ jsxs(Flex, { gap: 3, alignItems: "flex-start", children: [
+                    /* @__PURE__ */ jsx(Badge, { background: "success600", textColor: "neutral0", children: /* @__PURE__ */ jsx(Check, {}) }),
+                    /* @__PURE__ */ jsx(Typography, { size: "sm", children: i18n("plugin.legend.indexing-complete", "Indexing complete") })
+                  ] }),
+                  /* @__PURE__ */ jsxs(Flex, { gap: 3, alignItems: "flex-start", children: [
+                    /* @__PURE__ */ jsx(Badge, { background: "warning600", textColor: "neutral0", children: /* @__PURE__ */ jsx(RefreshIcon, { size: 16, color: "white" }) }),
+                    /* @__PURE__ */ jsx(Typography, { size: "sm", children: i18n("plugin.legend.indexing-in-progress", "Indexing in progress") })
+                  ] })
+                ] })
+              ] }),
+              /* @__PURE__ */ jsxs(Box, { flex: 1, children: [
+                /* @__PURE__ */ jsx(Typography, { variant: "sigma", textColor: "neutral600", marginBottom: 3, children: i18n("plugin.legend.hooks", "HOOKS") }),
+                /* @__PURE__ */ jsxs(Flex, { direction: "column", gap: 3, paddingTop: 2, alignItems: "flex-start", children: [
+                  /* @__PURE__ */ jsxs(Flex, { gap: 3, alignItems: "flex-start", children: [
+                    /* @__PURE__ */ jsx(Badge, { background: "success600", textColor: "neutral0", children: /* @__PURE__ */ jsx(Check, {}) }),
+                    /* @__PURE__ */ jsx(Typography, { size: "sm", children: i18n("plugin.legend.hooks-active", "Hooks active - automatic sync enabled") })
+                  ] }),
+                  /* @__PURE__ */ jsxs(Flex, { gap: 3, alignItems: "flex-start", children: [
+                    /* @__PURE__ */ jsx(Badge, { background: "neutral900", textColor: "neutral0", children: /* @__PURE__ */ jsx(DangerIcon, { size: 16, color: "white" }) }),
+                    /* @__PURE__ */ jsx(Typography, { size: "sm", children: i18n(
+                      "plugin.legend.hooks-inactive",
+                      "Hooks not active - manual reload required"
+                    ) })
+                  ] })
+                ] })
+              ] })
+            ] }),
+            /* @__PURE__ */ jsxs(Box, { children: [
+              /* @__PURE__ */ jsx(Typography, { variant: "sigma", textColor: "neutral600", marginBottom: 3, children: i18n("plugin.legend.actions", "ACTIONS") }),
+              /* @__PURE__ */ jsxs(Flex, { direction: "column", gap: 2, alignItems: "flex-start", children: [
+                /* @__PURE__ */ jsxs(Typography, { size: "sm", children: [
+                  /* @__PURE__ */ jsx("strong", { children: i18n("plugin.button.update", "Update") }),
+                  " —",
+                  " ",
+                  i18n(
+                    "plugin.legend.update",
+                    "Sync & refresh the index with the latest entries without deleting existing data."
+                  )
+                ] }),
+                /* @__PURE__ */ jsxs(Typography, { size: "sm", children: [
+                  /* @__PURE__ */ jsx("strong", { children: i18n("plugin.button.reindex", "Reindex") }),
+                  " —",
+                  " ",
+                  i18n(
+                    "plugin.legend.reindex",
+                    "Full rebuild: delete all indexed documents and reindex everything from scratch."
+                  )
+                ] })
+              ] })
+            ] })
+          ]
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx(Box, { background: "neutral0", hasRadius: true, children: /* @__PURE__ */ jsxs(Table, { colCount: COL_COUNT, rowCount: ROW_COUNT, children: [
+      /* @__PURE__ */ jsx("thead", { children: /* @__PURE__ */ jsxs(Tr, { children: [
+        /* @__PURE__ */ jsx(Td, { children: /* @__PURE__ */ jsx(Typography, { variant: "sigma", textColor: "neutral600", children: i18n("plugin.table.header.index", "Index") }) }),
+        /* @__PURE__ */ jsx(Td, { children: /* @__PURE__ */ jsx(Typography, { variant: "sigma", textColor: "neutral600", children: i18n("plugin.table.header.name", "Name") }) }),
+        /* @__PURE__ */ jsx(Td, { children: /* @__PURE__ */ jsx(Typography, { variant: "sigma", textColor: "neutral600", children: i18n("plugin.table.header.in-meilisearch", "In MeiliSearch") }) }),
+        /* @__PURE__ */ jsx(Td, { children: /* @__PURE__ */ jsx(Typography, { variant: "sigma", textColor: "neutral600", children: i18n("plugin.table.header.database", "Database") }) }),
+        /* @__PURE__ */ jsx(Td, { children: /* @__PURE__ */ jsx(Typography, { variant: "sigma", textColor: "neutral600", children: i18n("plugin.table.header.indexed", "Indexed") }) }),
+        /* @__PURE__ */ jsx(Td, { children: /* @__PURE__ */ jsx(Typography, { variant: "sigma", textColor: "neutral600", children: i18n("plugin.table.header.sync", "Sync %") }) }),
+        /* @__PURE__ */ jsx(Td, { children: /* @__PURE__ */ jsx(Typography, { variant: "sigma", textColor: "neutral600", children: i18n("plugin.table.header.actions", "Actions") }) }),
+        /* @__PURE__ */ jsx(Td, {})
+      ] }) }),
+      /* @__PURE__ */ jsx(Tbody, { children: contentTypes.length === 0 ? /* @__PURE__ */ jsx(Tr, { children: /* @__PURE__ */ jsx(Td, { colSpan: COL_COUNT, children: /* @__PURE__ */ jsx(Box, { padding: 4, children: /* @__PURE__ */ jsx(Typography, { children: i18n("plugin.noConfiguredTypes", "No content types configured") }) }) }) }) : contentTypes.map((contentType) => /* @__PURE__ */ jsxs(Tr, { children: [
+        /* @__PURE__ */ jsx(Td, { children: /* @__PURE__ */ jsx(
+          Checkbox,
+          {
+            checked: contentType.isIndexed,
+            onCheckedChange: () => {
+              handleToggle(contentType.name);
+            },
+            disabled: loadingState[contentType.name],
+            "aria-label": `Toggle indexing for ${contentType.name}`
+          }
+        ) }),
+        /* @__PURE__ */ jsxs(Td, { children: [
+          /* @__PURE__ */ jsx(Typography, { weight: "bold", children: contentType.displayName || contentType.name }),
+          /* @__PURE__ */ jsx(
+            Typography,
+            {
+              variant: "pi",
+              textColor: "neutral600",
+              fontSize: 12,
+              style: { display: "block" },
+              children: contentType.uid
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx(Td, { children: contentType.isIndexed ? /* @__PURE__ */ jsx(Badge, { background: "success600", textColor: "neutral0", children: /* @__PURE__ */ jsx(Check, {}) }) : /* @__PURE__ */ jsx(Badge, { background: "neutral900", textColor: "neutral0", children: /* @__PURE__ */ jsx(XIcon, { size: 16, color: "white" }) }) }),
+        /* @__PURE__ */ jsx(Td, { children: /* @__PURE__ */ jsx(Typography, { size: "sm", children: contentType.total || 0 }) }),
+        /* @__PURE__ */ jsx(Td, { children: /* @__PURE__ */ jsx(Typography, { size: "sm", children: contentType.indexed || 0 }) }),
+        /* @__PURE__ */ jsx(Td, { children: contentType.isSynced ? /* @__PURE__ */ jsxs(Flex, { gap: 2, alignItems: "center", children: [
+          /* @__PURE__ */ jsx(Badge, { background: "success600", textColor: "neutral0", children: /* @__PURE__ */ jsx(Check, {}) }),
+          /* @__PURE__ */ jsxs(Typography, { size: "sm", weight: "bold", children: [
+            contentType.syncPercentage || 0,
+            "%"
+          ] })
+        ] }) : /* @__PURE__ */ jsxs(Flex, { gap: 2, alignItems: "center", children: [
+          /* @__PURE__ */ jsx(Badge, { background: "warning600", textColor: "neutral0", children: /* @__PURE__ */ jsx(DangerIcon, { size: 16, color: "white" }) }),
+          /* @__PURE__ */ jsxs(Typography, { size: "sm", children: [
+            contentType.syncPercentage || 0,
+            "%"
+          ] })
+        ] }) }),
+        /* @__PURE__ */ jsx(Td, { children: contentType.isIndexed && /* @__PURE__ */ jsxs(Flex, { gap: 2, children: [
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              size: "S",
+              variant: "secondary",
+              disabled: loadingState[contentType.name],
+              onClick: () => handleUpdate(contentType.name),
+              children: i18n("plugin.button.update", "Update")
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              size: "S",
+              variant: "tertiary",
+              disabled: loadingState[contentType.name],
+              onClick: () => handleReindex(contentType.name),
+              children: i18n("plugin.button.reindex", "Reindex")
+            }
+          )
+        ] }) }),
+        /* @__PURE__ */ jsx(Td, { children: loadingState[contentType.name] && /* @__PURE__ */ jsx(Loader, {}) })
+      ] }, contentType.uid || contentType.name)) })
+    ] }) })
+  ] });
+});
+CollectionsTable.displayName = "CollectionsTable";
+export {
+  CollectionsTable as default
+};