strapi-plugin-algolia-sync 1.0.0

package/README.md

@@ -0,0 +1,182 @@
+# strapi-plugin-algolia
+
+Strapi v5 plugin that syncs content to Algolia automatically via lifecycle hooks, with a manual "Index all items" button in the admin panel.
+
+## Features
+
+- Auto-sync on publish, unpublish, and delete via lifecycle hooks
+- Bulk reindex button in content-manager list view (per collection type)
+- Optional full reindex on boot
+- Multi-locale support
+- Domain/tag filtering support
+- Rich-text (CKEditor) HTML stripping
+- Configurable per-content-type: index name, title field, URL pattern
+
+---
+
+## Installation
+
+### Option A — Local path (recommended for development)
+
+Copy or symlink this folder anywhere, then reference it by path.
+
+### Option B — npm (after publishing)
+
+```bash
+npm install strapi-plugin-algolia
+```
+
+---
+
+## Setup
+
+### 1. Register the plugin in `config/plugins.js`
+
+```js
+// config/plugins.js
+module.exports = ({ env }) => ({
+  algolia: {
+    enabled: true,
+    resolve: '../strapi-plugin-algolia', // path to plugin folder (local) OR omit for npm
+    config: {
+      // Algolia credentials — prefer env vars over hardcoding
+      appId: env('ALGOLIA_APP_ID', ''),
+      apiKey: env('ALGOLIA_ADMIN_API_KEY', ''),
+
+      // Optional: prefix every index name (e.g. 'prod_', 'staging_')
+      indexPrefix: env('ALGOLIA_INDEX_PREFIX', ''),
+
+      // Run a full reindex every time Strapi boots (default: false)
+      reindexOnBoot: env.bool('ALGOLIA_REINDEX_ON_BOOT', false),
+
+      // Index name shared by all single-type content types (default: 'static_pages')
+      singleTypeIndexName: 'static_pages',
+
+      // UIDs to never index, even if listed in contentTypes
+      skipContentTypes: [
+        'api::tag.tag',
+        'api::category.category',
+      ],
+
+      // Content types to index
+      contentTypes: [
+        // Collection type — each entry becomes its own Algolia record
+        {
+          uid: 'api::article.article',
+          indexName: 'articles',        // Algolia index name
+          titleField: 'title',          // field (dot-notation ok, e.g. 'banner.title')
+          urlPattern: '/articles/{slug}', // {slug} → entry.slug
+        },
+
+        // Collection type with a static title
+        {
+          uid: 'api::team-member.team-member',
+          indexName: 'team',
+          titleField: 'name',
+          urlPattern: '/about/team/{slug}',
+        },
+
+        // Single type — goes into the shared singleTypeIndexName index
+        {
+          uid: 'api::home-page.home-page',
+          staticTitle: 'Home',          // hard-coded; no titleField needed
+          urlPattern: '/',
+        },
+
+        {
+          uid: 'api::about-page.about-page',
+          staticTitle: 'About',
+          urlPattern: '/about',
+        },
+      ],
+    },
+  },
+});
+```
+
+### 2. Add environment variables
+
+```env
+ALGOLIA_APP_ID=your_app_id
+ALGOLIA_ADMIN_API_KEY=your_admin_api_key
+ALGOLIA_INDEX_PREFIX=prod_          # optional
+ALGOLIA_REINDEX_ON_BOOT=false       # optional
+```
+
+---
+
+## How it works
+
+### Lifecycle hooks (automatic sync)
+
+| Event | Behaviour |
+|---|---|
+| `afterCreate` | Indexes the entry if it is published |
+| `afterUpdate` | Indexes if published; removes from index if unpublished |
+| `afterDelete` | Removes from index if it was published |
+
+### Algolia record shape
+
+Every indexed entry produces:
+
+```json
+{
+  "objectID": "api::article.article::abc123::en",
+  "title": "My Article",
+  "content": "Plain text extracted from all string/richtext/component fields",
+  "url": "/articles/my-article",
+  "domains": ["godrej-industries", "another-domain"]
+}
+```
+
+### Admin panel — "Index all items"
+
+A button appears in the content-manager list view for every collection type listed in `contentTypes`. Clicking it bulk-reindexes all published entries (paginated, 100 per batch).
+
+---
+
+## contentTypes config reference
+
+| Key | Type | Required | Description |
+|---|---|---|---|
+| `uid` | string | Yes | Strapi content type UID e.g. `api::article.article` |
+| `indexName` | string | No | Algolia index name. Defaults to the schema's `pluralName` (collections) or `singleTypeIndexName` (single types) |
+| `titleField` | string | No | Dot-notation path to the title field e.g. `banner.title` |
+| `staticTitle` | string | No | Hard-coded title string (useful for single types) |
+| `urlPattern` | string | No | Frontend URL with `{slug}` placeholder. Defaults to `/{pluralName}/{slug}` |
+
+If both `titleField` and `staticTitle` are set, `staticTitle` takes precedence.
+If neither is set, the plugin falls back to the first of `title`, `name`, `heading` fields found on the entry, then `banner.title`, then the schema's `displayName`.
+
+---
+
+## Plugin services (for advanced use)
+
+All services are accessible within custom Strapi code:
+
+```js
+// Index a single entry manually
+await strapi.plugin('algolia').service('algoliaSync').indexEntry(uid, documentId, locale);
+
+// Remove a single entry
+await strapi.plugin('algolia').service('algoliaSync').removeEntry(uid, documentId, locale);
+
+// Reindex an entire collection
+await strapi.plugin('algolia').service('algoliaSync').reindexCollectionUid(uid);
+
+// Full reindex of all configured content types
+await strapi.plugin('algolia').service('algoliaSync').fullReindex();
+```
+
+---
+
+## Migrating from the inline integration (gil-corp-strapi)
+
+If you are migrating this project away from the old inline utilities:
+
+1. Add the plugin config to `config/plugins.js` and copy the content type definitions from the old `src/utils/algolia-config.js`.
+2. Remove `src/utils/algolia.js`, `src/utils/algolia-sync.js`, `src/utils/algolia-config.js`.
+3. Remove the Algolia code from `src/index.js` (lifecycle hooks + boot reindex).
+4. Remove `src/api/algolia-admin/` (controller + routes).
+5. Remove the `AlgoliaIndexAllButton` injection from `src/admin/app.js`.
+6. Set `resolve` to the plugin folder path in `config/plugins.js`.

package/admin/src/components/AlgoliaIndexAllButton.jsx

@@ -0,0 +1,89 @@
+import { useState, useEffect } from 'react';
+import { useParams } from 'react-router-dom';
+import { Button, Box } from '@strapi/design-system';
+import {
+  useFetchClient,
+  useNotification,
+  useAPIErrorHandler,
+} from '@strapi/strapi/admin';
+
+/**
+ * Renders an "Index all items" button in the content-manager list view actions bar.
+ * Only visible for collection types that are configured in the plugin's contentTypes array.
+ */
+const AlgoliaIndexAllButton = () => {
+  const { slug } = useParams();
+  const { get, post } = useFetchClient();
+  const { toggleNotification } = useNotification();
+  const { formatAPIError } = useAPIErrorHandler();
+  const [loading, setLoading] = useState(false);
+  const [allowedUids, setAllowedUids] = useState(null);
+
+  useEffect(() => {
+    let cancelled = false;
+    (async () => {
+      try {
+        const { data } = await get(
+          '/api/algolia/algolia-admin/configured-collection-uids'
+        );
+        const uids = data?.data?.uids ?? data?.uids ?? [];
+        if (!cancelled) {
+          setAllowedUids(new Set(Array.isArray(uids) ? uids : []));
+        }
+      } catch {
+        if (!cancelled) setAllowedUids(new Set());
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [get]);
+
+  if (
+    allowedUids === null ||
+    !slug ||
+    !slug.startsWith('api::') ||
+    !allowedUids.has(slug)
+  ) {
+    return null;
+  }
+
+  const handleClick = async () => {
+    setLoading(true);
+    try {
+      const { data } = await post(
+        '/api/algolia/algolia-admin/reindex-collection',
+        { uid: slug }
+      );
+      const indexed = data?.data?.indexed ?? data?.indexed;
+      const indexName = data?.data?.indexName ?? data?.indexName;
+      toggleNotification({
+        type: 'success',
+        message: `Indexed ${indexed ?? 0} published entr${indexed === 1 ? 'y' : 'ies'}${indexName ? ` → ${indexName}` : ''}.`,
+      });
+    } catch (err) {
+      toggleNotification({
+        type: 'danger',
+        message: formatAPIError(err),
+      });
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  return (
+    <Box paddingRight={2}>
+      <Button
+        type="button"
+        variant="primary"
+        size="S"
+        loading={loading}
+        onClick={handleClick}
+      >
+        Index all items
+      </Button>
+    </Box>
+  );
+};
+
+export default AlgoliaIndexAllButton;

package/admin/src/index.js

@@ -0,0 +1,20 @@
+import AlgoliaIndexAllButton from './components/AlgoliaIndexAllButton';
+
+export default {
+  register(app) {
+    app.registerPlugin({
+      id: 'algolia',
+      name: 'Algolia Search',
+    });
+  },
+
+  bootstrap(app) {
+    const contentManager = app.getPlugin('content-manager');
+    if (contentManager) {
+      contentManager.injectComponent('listView', 'actions', {
+        name: 'algolia.index-all',
+        Component: AlgoliaIndexAllButton,
+      });
+    }
+  },
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "strapi-plugin-algolia-sync",
+  "version": "1.0.0",
+  "description": "Algolia search integration plugin for Strapi v5 — auto-syncs content via lifecycle hooks, supports bulk reindex from the admin panel.",
+  "main": "./strapi-server.js",
+  "strapi": {
+    "name": "algolia",
+    "displayName": "Algolia Search",
+    "description": "Automatically sync Strapi content to Algolia indexes with lifecycle hooks and admin UI.",
+    "kind": "plugin"
+  },
+  "scripts": {
+    "build": "strapi-plugin build",
+    "watch": "strapi-plugin watch"
+  },
+  "files": [
+    "strapi-server.js",
+    "strapi-admin.js",
+    "server/",
+    "admin/",
+    "dist/"
+  ],
+  "dependencies": {
+    "algoliasearch": "^5.50.1"
+  },
+  "devDependencies": {
+    "@strapi/plugin-sdk": "^0.0.7"
+  },
+  "peerDependencies": {
+    "@strapi/strapi": "^5.0.0"
+  },
+  "keywords": [
+    "strapi",
+    "algolia",
+    "search",
+    "plugin",
+    "strapi-plugin"
+  ],
+  "license": "MIT",
+  "author": "akashkcode7",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/akashkcode7/strapi-plugin-algolia.git"
+  },
+  "homepage": "https://github.com/akashkcode7/strapi-plugin-algolia#readme",
+  "bugs": {
+    "url": "https://github.com/akashkcode7/strapi-plugin-algolia/issues"
+  }
+}

package/server/config.js

@@ -0,0 +1,101 @@
+'use strict';
+
+/**
+ * Default plugin configuration.
+ *
+ * Users override these values in their project's config/plugins.js:
+ *
+ *   module.exports = ({ env }) => ({
+ *     algolia: {
+ *       enabled: true,
+ *       resolve: '../strapi-plugin-algolia',   // path to this plugin
+ *       config: {
+ *         appId: env('ALGOLIA_APP_ID'),
+ *         apiKey: env('ALGOLIA_ADMIN_API_KEY'),
+ *         indexPrefix: env('ALGOLIA_INDEX_PREFIX', ''),
+ *         reindexOnBoot: env.bool('ALGOLIA_REINDEX_ON_BOOT', false),
+ *         singleTypeIndexName: 'static_pages',
+ *         skipContentTypes: ['api::tag.tag'],
+ *         contentTypes: [
+ *           {
+ *             uid: 'api::article.article',
+ *             indexName: 'articles',
+ *             titleField: 'title',
+ *             urlPattern: '/articles/{slug}',
+ *           },
+ *           {
+ *             uid: 'api::home-page.home-page',
+ *             indexName: 'static_pages',
+ *             staticTitle: 'Home',
+ *             urlPattern: '/',
+ *           },
+ *         ],
+ *       },
+ *     },
+ *   });
+ */
+module.exports = {
+  default: {
+    /**
+     * Algolia Application ID.
+     * Falls back to process.env.ALGOLIA_APP_ID if not set here.
+     */
+    appId: '',
+
+    /**
+     * Algolia Admin API Key (write access).
+     * Falls back to process.env.ALGOLIA_ADMIN_API_KEY if not set here.
+     */
+    apiKey: '',
+
+    /**
+     * Optional prefix added to every index name (e.g. "prod_", "dev_").
+     * Falls back to process.env.ALGOLIA_INDEX_PREFIX.
+     */
+    indexPrefix: '',
+
+    /**
+     * When true, a full reindex runs on every Strapi boot.
+     */
+    reindexOnBoot: false,
+
+    /**
+     * When true, the plugin recursively extracts domain/domains relation values
+     * from each entry and stores them as a `domains` array in Algolia.
+     * Only enable this if your project has domain-based content filtering.
+     * Default: false
+     */
+    enableDomains: false,
+
+    /**
+     * Index name shared by all single-type content types.
+     */
+    singleTypeIndexName: 'static_pages',
+
+    /**
+     * UIDs to explicitly exclude from indexing (lifecycle hooks + bulk reindex).
+     * Example: ['api::tag.tag', 'api::category.category']
+     */
+    skipContentTypes: [],
+
+    /**
+     * Content types to index. Each entry:
+     *   uid          {string}  — Strapi content type UID, e.g. 'api::article.article'
+     *   indexName    {string}  — Algolia index name (optional; defaults to pluralName for
+     *                           collections, singleTypeIndexName for single types)
+     *   titleField   {string}  — Dot-notation path to the title field, e.g. 'banner.title'
+     *   staticTitle  {string}  — Hard-coded title (useful for single-type pages)
+     *   urlPattern   {string}  — Frontend URL template; {slug} is replaced with the entry slug
+     */
+    contentTypes: [],
+  },
+
+  validator(config) {
+    if (!Array.isArray(config.contentTypes)) {
+      throw new Error('[strapi-plugin-algolia] `config.contentTypes` must be an array');
+    }
+    if (!Array.isArray(config.skipContentTypes)) {
+      throw new Error('[strapi-plugin-algolia] `config.skipContentTypes` must be an array');
+    }
+  },
+};

package/server/controllers/algolia-admin.js

@@ -0,0 +1,88 @@
+'use strict';
+
+module.exports = ({ strapi }) => {
+  /**
+   * Validates the request carries a valid Strapi admin access token.
+   * Uses the same session manager that the admin panel uses internally.
+   * NOTE: Routes are auth:false so we perform auth manually here to allow
+   * the Strapi admin JWT (not the public API token) to authorize these calls.
+   */
+  function isValidAdminAccessToken(ctx) {
+    const auth = ctx.request.header.authorization;
+    if (!auth || !auth.startsWith('Bearer ')) return false;
+
+    const token = auth.slice(7).trim();
+    if (!token) return false;
+
+    try {
+      const session = strapi.sessionManager?.('admin');
+      if (!session?.validateAccessToken) return false;
+      return session.validateAccessToken(token).isValid === true;
+    } catch {
+      return false;
+    }
+  }
+
+  return {
+    /**
+     * GET /api/algolia/algolia-admin/configured-collection-uids
+     * Returns collection type UIDs configured for indexing.
+     * Used by the admin panel to decide whether to show "Index all" button.
+     */
+    async configuredCollectionUids(ctx) {
+      if (!isValidAdminAccessToken(ctx)) {
+        return ctx.unauthorized('Admin authentication required');
+      }
+
+      ctx.body = {
+        data: {
+          uids: strapi
+            .plugin('algolia')
+            .service('algoliaConfig')
+            .getConfiguredCollectionTypeUIDs(),
+        },
+      };
+    },
+
+    /**
+     * POST /api/algolia/algolia-admin/reindex-collection
+     * Body: { uid: 'api::article.article' }
+     * Triggers a bulk reindex for the given collection type.
+     */
+    async reindexCollection(ctx) {
+      if (!isValidAdminAccessToken(ctx)) {
+        return ctx.unauthorized('Admin authentication required');
+      }
+
+      const uid = ctx.request.body?.uid;
+      if (!uid || typeof uid !== 'string') {
+        return ctx.badRequest('Request body must include string "uid"');
+      }
+
+      // Validate uid against the configured allowlist before touching the service
+      const allowedUids = strapi
+        .plugin('algolia')
+        .service('algoliaConfig')
+        .getConfiguredCollectionTypeUIDs();
+
+      if (!allowedUids.includes(uid)) {
+        return ctx.badRequest('The provided uid is not configured for indexing');
+      }
+
+      try {
+        const { count, indexName } = await strapi
+          .plugin('algolia')
+          .service('algoliaSync')
+          .reindexCollectionUid(uid);
+
+        ctx.body = {
+          data: { uid, indexName, indexed: count },
+        };
+      } catch (err) {
+        strapi.log.warn(`[Algolia] reindexCollection: ${err.message}`);
+        // Return a generic message — don't leak internal details to the client
+        return ctx.badRequest('Reindex failed. Check server logs for details.');
+      }
+    },
+  };
+};

package/server/controllers/index.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = {
+  algoliaAdmin: require('./algolia-admin'),
+};

package/server/index.js

@@ -0,0 +1,89 @@
+'use strict';
+
+const config = require('./config');
+const services = require('./services');
+const controllers = require('./controllers');
+const routes = require('./routes');
+
+module.exports = {
+  config,
+  services,
+  controllers,
+  routes,
+
+  register({ strapi: _strapi }) {},
+
+  bootstrap({ strapi: _strapi }) {
+    const algoliaConfig = _strapi.plugin('algolia').service('algoliaConfig');
+    const algoliaSync = _strapi.plugin('algolia').service('algoliaSync');
+    const algoliaClient = _strapi.plugin('algolia').service('algoliaClient');
+
+    // ── Warn early if credentials are missing ──────────────────────────────
+
+    if (!algoliaClient.getClient()) {
+      _strapi.log.warn(
+        '[Algolia] Plugin is active but credentials are not configured. ' +
+        'Set ALGOLIA_APP_ID and ALGOLIA_ADMIN_API_KEY (or appId/apiKey in config/plugins.js). ' +
+        'Indexing will be silently skipped until credentials are provided.'
+      );
+    }
+
+    // ── Lifecycle hooks ────────────────────────────────────────────────────
+
+    _strapi.db.lifecycles.subscribe({
+      async afterCreate(event) {
+        const { model, result } = event;
+        if (!result?.publishedAt) return;
+        if (!algoliaConfig.shouldIndex(model.uid)) return;
+
+        try {
+          await algoliaSync.indexEntry(model.uid, result.documentId, result.locale);
+        } catch (e) {
+          _strapi.log.error(`[Algolia] afterCreate: ${e.message}`);
+        }
+      },
+
+      async afterUpdate(event) {
+        const { model, result } = event;
+        if (!algoliaConfig.shouldIndex(model.uid)) return;
+
+        if (result?.publishedAt) {
+          try {
+            await algoliaSync.indexEntry(model.uid, result.documentId, result.locale);
+          } catch (e) {
+            _strapi.log.error(`[Algolia] afterUpdate: ${e.message}`);
+          }
+        } else {
+          try {
+            await algoliaSync.removeEntry(model.uid, result.documentId);
+          } catch (e) {
+            _strapi.log.error(`[Algolia] afterUpdate (unpublish): ${e.message}`);
+          }
+        }
+      },
+
+      async afterDelete(event) {
+        const { model, result } = event;
+        if (!algoliaConfig.shouldIndex(model.uid)) return;
+        if (!result?.publishedAt) return;
+
+        try {
+          await algoliaSync.removeEntry(model.uid, result.documentId);
+        } catch (e) {
+          _strapi.log.error(`[Algolia] afterDelete: ${e.message}`);
+        }
+      },
+    });
+
+    // ── Boot-time reindex ──────────────────────────────────────────────────
+
+    const pluginCfg = _strapi.config.get('plugin.algolia') || {};
+    if (pluginCfg.reindexOnBoot) {
+      algoliaSync
+        .fullReindex()
+        .catch((err) =>
+          _strapi.log.error(`[Algolia] Boot reindex failed: ${err.message}`)
+        );
+    }
+  },
+};

package/server/routes/algolia-admin.js

@@ -0,0 +1,27 @@
+'use strict';
+
+module.exports = {
+  type: 'content-api',
+  routes: [
+    {
+      method: 'GET',
+      path: '/algolia-admin/configured-collection-uids',
+      handler: 'algoliaAdmin.configuredCollectionUids',
+      config: {
+        auth: false,
+        policies: [],
+        middlewares: [],
+      },
+    },
+    {
+      method: 'POST',
+      path: '/algolia-admin/reindex-collection',
+      handler: 'algoliaAdmin.reindexCollection',
+      config: {
+        auth: false,
+        policies: [],
+        middlewares: [],
+      },
+    },
+  ],
+};

package/server/routes/index.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = [require('./algolia-admin')];

package/server/services/algolia-client.js

@@ -0,0 +1,119 @@
+'use strict';
+
+const { algoliasearch } = require('algoliasearch');
+
+/**
+ * Algolia client service.
+ *
+ * Credentials are read from plugin config first, then fall back to env vars:
+ *   ALGOLIA_APP_ID, ALGOLIA_ADMIN_API_KEY, ALGOLIA_INDEX_PREFIX
+ */
+module.exports = ({ strapi }) => {
+  let client = null;
+
+  function getPluginCfg() {
+    return strapi.config.get('plugin.algolia') || {};
+  }
+
+  function getClient() {
+    if (client) return client;
+
+    const cfg = getPluginCfg();
+    const appId = cfg.appId || process.env.ALGOLIA_APP_ID;
+    const apiKey = cfg.apiKey || process.env.ALGOLIA_ADMIN_API_KEY;
+
+    if (!appId || !apiKey) return null;
+
+    client = algoliasearch(appId, apiKey);
+    return client;
+  }
+
+  function getIndexPrefix() {
+    const cfg = getPluginCfg();
+    return cfg.indexPrefix || process.env.ALGOLIA_INDEX_PREFIX || '';
+  }
+
+  function prefixedIndex(name) {
+    return `${getIndexPrefix()}${name}`;
+  }
+
+  function stripHtml(html) {
+    if (!html || typeof html !== 'string') return '';
+    return html
+      // Remove script/style blocks and their content entirely
+      .replace(/<script[\s\S]*?<\/script>/gi, ' ')
+      .replace(/<style[\s\S]*?<\/style>/gi, ' ')
+      // Remove HTML comments
+      .replace(/<!--[\s\S]*?-->/g, ' ')
+      // Remove all remaining tags (including ones with nested angle brackets)
+      .replace(/<[^>]*>/g, ' ')
+      // Decode common HTML entities
+      .replace(/&nbsp;/gi, ' ')
+      .replace(/&amp;/gi, '&')
+      .replace(/&lt;/gi, '<')
+      .replace(/&gt;/gi, '>')
+      .replace(/&quot;/gi, '"')
+      .replace(/&#?\w+;/gi, ' ')
+      // Collapse whitespace
+      .replace(/\s+/g, ' ')
+      .trim();
+  }
+
+  async function saveObjects(indexName, objects) {
+    const algolia = getClient();
+    if (!algolia) {
+      strapi.log.warn('[Algolia] Client not configured — skipping save');
+      return;
+    }
+
+    try {
+      const result = await algolia.saveObjects({
+        indexName: prefixedIndex(indexName),
+        objects,
+      });
+      strapi.log.info(
+        `[Algolia] Saved ${objects.length} object(s) → "${prefixedIndex(indexName)}" | taskID: ${JSON.stringify(result)}`
+      );
+    } catch (err) {
+      strapi.log.error(`[Algolia] Save error (${indexName}): ${err.message}`);
+    }
+  }
+
+  async function deleteObject(indexName, objectID) {
+    const algolia = getClient();
+    if (!algolia) return;
+
+    try {
+      await algolia.deleteObject({
+        indexName: prefixedIndex(indexName),
+        objectID,
+      });
+      strapi.log.info(
+        `[Algolia] Deleted "${objectID}" ← "${prefixedIndex(indexName)}"`
+      );
+    } catch (err) {
+      strapi.log.error(`[Algolia] Delete error (${indexName}): ${err.message}`);
+    }
+  }
+
+  async function clearIndex(indexName) {
+    const algolia = getClient();
+    if (!algolia) return;
+
+    try {
+      await algolia.clearObjects({ indexName: prefixedIndex(indexName) });
+      strapi.log.info(`[Algolia] Cleared index "${prefixedIndex(indexName)}"`);
+    } catch (err) {
+      strapi.log.error(`[Algolia] Clear error (${indexName}): ${err.message}`);
+    }
+  }
+
+  return {
+    getClient,
+    stripHtml,
+    saveObjects,
+    deleteObject,
+    clearIndex,
+    prefixedIndex,
+  };
+};

package/server/services/algolia-config.js

@@ -0,0 +1,93 @@
+'use strict';
+
+/**
+ * Config service — replaces the hardcoded algolia-config.js from the original project.
+ *
+ * All content type configuration is driven by the plugin config defined in the
+ * consuming project's config/plugins.js under the `contentTypes` array.
+ */
+module.exports = ({ strapi }) => {
+  function getPluginCfg() {
+    return strapi.config.get('plugin.algolia') || {};
+  }
+
+  function getConfiguredContentTypes() {
+    return getPluginCfg().contentTypes || [];
+  }
+
+  function getSkipContentTypes() {
+    return getPluginCfg().skipContentTypes || [];
+  }
+
+  function getSingleTypeIndexName() {
+    return getPluginCfg().singleTypeIndexName || 'static_pages';
+  }
+
+  const DANGEROUS_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+
+  /** Build a uid → override map from the configured array. Uses null-prototype object to prevent prototype pollution. */
+  function getContentTypeMap() {
+    const map = Object.create(null);
+    for (const ct of getConfiguredContentTypes()) {
+      if (ct && typeof ct.uid === 'string' && ct.uid.startsWith('api::') && !DANGEROUS_KEYS.has(ct.uid)) {
+        map[ct.uid] = ct;
+      }
+    }
+    return map;
+  }
+
+  function shouldIndex(uid) {
+    if (!uid || typeof uid !== 'string') return false;
+    if (!uid.startsWith('api::')) return false;
+    if (DANGEROUS_KEYS.has(uid)) return false;
+    if (getSkipContentTypes().includes(uid)) return false;
+    return uid in getContentTypeMap();
+  }
+
+  function getConfig(uid) {
+    if (!shouldIndex(uid)) return null;
+
+    const schema = strapi.contentTypes[uid];
+    if (!schema) return null;
+
+    const override = getContentTypeMap()[uid];
+    if (!override) return null;
+
+    const isSingleType = schema.kind === 'singleType';
+    const singleTypeIndexName = getSingleTypeIndexName();
+
+    const indexName =
+      override.indexName ||
+      (isSingleType
+        ? singleTypeIndexName
+        : schema.info.pluralName.replace(/-/g, '_'));
+
+    return {
+      indexName,
+      titleField: override.titleField || null,
+      staticTitle: override.staticTitle || null,
+      urlPattern: override.urlPattern || `/${schema.info.pluralName}/{slug}`,
+      isSingleType,
+    };
+  }
+
+  function getAllIndexableUIDs() {
+    return getConfiguredContentTypes()
+      .map((ct) => ct.uid)
+      .filter((uid) => uid && strapi.contentTypes[uid]);
+  }
+
+  /** Collection type UIDs only — used by the admin "Index all" allowlist. */
+  function getConfiguredCollectionTypeUIDs() {
+    return getAllIndexableUIDs().filter(
+      (uid) => strapi.contentTypes[uid]?.kind === 'collectionType'
+    );
+  }
+
+  return {
+    shouldIndex,
+    getConfig,
+    getAllIndexableUIDs,
+    getConfiguredCollectionTypeUIDs,
+  };
+};

package/server/services/algolia-sync.js

@@ -0,0 +1,392 @@
+'use strict';
+
+const SKIP_KEYS = new Set([
+  'id',
+  'documentId',
+  'createdAt',
+  'updatedAt',
+  'publishedAt',
+  'locale',
+  'createdBy',
+  'updatedBy',
+]);
+
+/**
+ * Fields skipped when extracting searchable text content.
+ * Add project-specific URL/ID fields here if needed.
+ */
+const SKIP_CONTENT_FIELDS = new Set([
+  'slug',
+  'order',
+  'date',
+  'linkedin_url',
+  'vimeo_id',
+  'vimeo_mobile_id',
+  'external_url',
+  'youtube_url',
+  'video_url',
+]);
+
+module.exports = ({ strapi }) => {
+  function clientService() {
+    return strapi.plugin('algolia').service('algoliaClient');
+  }
+
+  function configService() {
+    return strapi.plugin('algolia').service('algoliaConfig');
+  }
+
+  // ── Text extraction helpers ──────────────────────────────────────────────
+
+  function isMediaOrRelation(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+    return !!(value.mime || (value.documentId && value.id));
+  }
+
+  function extractTextFromObject(obj) {
+    if (!obj || typeof obj !== 'object') return '';
+
+    const { stripHtml } = clientService();
+    const parts = [];
+
+    for (const [key, value] of Object.entries(obj)) {
+      if (SKIP_KEYS.has(key)) continue;
+      if (isMediaOrRelation(value)) continue;
+
+      if (key === '__component' && value != null) {
+        parts.push(String(value).trim());
+        continue;
+      }
+
+      if (typeof value === 'string') {
+        parts.push(stripHtml(value));
+      } else if (Array.isArray(value)) {
+        for (const item of value) {
+          if (typeof item === 'string') {
+            parts.push(stripHtml(item));
+          } else if (item && typeof item === 'object' && !isMediaOrRelation(item)) {
+            parts.push(extractTextFromObject(item));
+          }
+        }
+      } else if (typeof value === 'object' && !isMediaOrRelation(value)) {
+        parts.push(extractTextFromObject(value));
+      }
+    }
+
+    return parts.filter(Boolean).join(' ');
+  }
+
+  const DANGEROUS_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+
+  function resolveNestedField(obj, path) {
+    return path.split('.').reduce((cur, key) => {
+      if (!cur || typeof cur !== 'object') return undefined;
+      if (DANGEROUS_KEYS.has(key)) return undefined;
+      return cur[key];
+    }, obj);
+  }
+
+  function findTitle(entry, schema, config) {
+    const { stripHtml } = clientService();
+
+    if (config.staticTitle) return config.staticTitle;
+
+    if (config.titleField) {
+      const raw = resolveNestedField(entry, config.titleField);
+      if (raw) return stripHtml(String(raw));
+    }
+
+    for (const field of ['title', 'name', 'heading']) {
+      if (entry[field] && typeof entry[field] === 'string') {
+        return stripHtml(entry[field]);
+      }
+    }
+
+    if (entry.banner) {
+      if (entry.banner.title) return stripHtml(String(entry.banner.title));
+      if (entry.banner.label) return stripHtml(String(entry.banner.label));
+    }
+
+    return schema.info.displayName || '';
+  }
+
+  function extractContent(entry, schema) {
+    const { stripHtml } = clientService();
+    const parts = [];
+
+    for (const [key, attr] of Object.entries(schema.attributes)) {
+      if (SKIP_CONTENT_FIELDS.has(key)) continue;
+      const value = entry[key];
+      if (value == null) continue;
+
+      if (attr.type === 'uid') continue;
+      if (attr.type === 'relation' || attr.type === 'media') continue;
+
+      if (
+        attr.type === 'string' ||
+        attr.type === 'text' ||
+        attr.type === 'richtext' ||
+        (attr.type === 'customField' &&
+          attr.customField === 'plugin::ckeditor5.CKEditor')
+      ) {
+        parts.push(stripHtml(String(value)));
+      } else if (attr.type === 'component') {
+        if (attr.repeatable && Array.isArray(value)) {
+          for (const item of value) parts.push(extractTextFromObject(item));
+        } else if (typeof value === 'object') {
+          parts.push(extractTextFromObject(value));
+        }
+      } else if (attr.type === 'dynamiczone' && Array.isArray(value)) {
+        for (const item of value) parts.push(extractTextFromObject(item));
+      }
+    }
+
+    return parts.filter(Boolean).join(' ');
+  }
+
+  // ── Populate builder ────────────────────────────────────────────────────
+
+  function buildPopulate(uid) {
+    const schema = strapi.contentTypes[uid];
+    if (!schema) return {};
+
+    const populate = {};
+    for (const [key, attr] of Object.entries(schema.attributes)) {
+      if (attr.type === 'component' || attr.type === 'dynamiczone') {
+        populate[key] = { populate: '*' };
+      }
+      if (attr.type === 'relation' && (key === 'domains' || key === 'domain')) {
+        populate[key] = { fields: ['title', 'slug', 'documentId'] };
+      }
+    }
+    return populate;
+  }
+
+  // ── Object ID + URL ──────────────────────────────────────────────────────
+
+  function buildObjectID(uid, documentId, locale) {
+    const parts = [uid, documentId];
+    if (locale) parts.push(locale);
+    return parts.join('::');
+  }
+
+  function buildUrl(entry, config) {
+    return config.urlPattern.replace('{slug}', entry.slug || entry.documentId || '');
+  }
+
+  // ── Domain extraction ────────────────────────────────────────────────────
+
+  function normalizeDomainValue(item) {
+    if (!item || typeof item !== 'object') return null;
+    return item.slug || item.title || item.documentId || null;
+  }
+
+  function collectDomainValues(value, set) {
+    if (!value) return;
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        const normalized = normalizeDomainValue(item);
+        if (normalized) set.add(normalized);
+      }
+      return;
+    }
+    const normalized = normalizeDomainValue(value);
+    if (normalized) set.add(normalized);
+  }
+
+  const MAX_TRAVERSE_DEPTH = 10;
+
+  function traverseForDomains(node, set, visited, depth = 0) {
+    if (depth > MAX_TRAVERSE_DEPTH) return;
+    if (!node || typeof node !== 'object') return;
+    if (visited.has(node)) return;
+    visited.add(node);
+
+    if (Array.isArray(node)) {
+      for (const item of node) traverseForDomains(item, set, visited, depth + 1);
+      return;
+    }
+
+    for (const [key, value] of Object.entries(node)) {
+      if (key === 'domain' || key === 'domains') {
+        collectDomainValues(value, set);
+      }
+      if (value && typeof value === 'object') {
+        traverseForDomains(value, set, visited, depth + 1);
+      }
+    }
+  }
+
+  function extractDomains(entry) {
+    const domains = new Set();
+    traverseForDomains(entry, domains, new Set());
+    return [...domains];
+  }
+
+  function isDomainsEnabled() {
+    return !!(strapi.config.get('plugin.algolia') || {}).enableDomains;
+  }
+
+  function buildRecord(entry, schema, cfg, uid, documentId, locale) {
+    const record = {
+      objectID: buildObjectID(uid, documentId, locale),
+      title: findTitle(entry, schema, cfg),
+      content: extractContent(entry, schema),
+      url: buildUrl(entry, cfg),
+    };
+    if (isDomainsEnabled()) {
+      record.domains = extractDomains(entry);
+    }
+    return record;
+  }
+
+  // ── Public sync methods ──────────────────────────────────────────────────
+
+  async function indexEntry(uid, documentId, locale) {
+    const cfg = configService().getConfig(uid);
+    if (!cfg) return;
+
+    try {
+      const populate = buildPopulate(uid);
+      const query = { documentId, populate, status: 'published' };
+      if (locale) query.locale = locale;
+
+      const entry = await strapi
+        .documents(/** @type {any} */ (uid))
+        .findOne(/** @type {any} */ (query));
+      if (!entry) return;
+
+      const schema = strapi.contentTypes[uid];
+      const loc = locale || entry.locale;
+
+      await clientService().saveObjects(cfg.indexName, [
+        buildRecord(entry, schema, cfg, uid, documentId, loc),
+      ]);
+    } catch (err) {
+      strapi.log.error(
+        `[Algolia] indexEntry failed for ${uid} (${documentId}): ${err.message}`
+      );
+    }
+  }
+
+  async function removeEntry(uid, documentId) {
+    const cfg = configService().getConfig(uid);
+    if (!cfg) return;
+    await clientService().deleteObject(cfg.indexName, documentId);
+  }
+
+  /**
+   * Reindex all published documents for one collection type UID.
+   * Returns { count, indexName }.
+   */
+  async function reindexCollectionUid(uid) {
+    if (!clientService().getClient()) {
+      throw new Error(
+        'Algolia is not configured (missing appId / apiKey)'
+      );
+    }
+
+    const schema = strapi.contentTypes[uid];
+    if (!schema || schema.kind !== 'collectionType') {
+      throw new Error('Not a collection type');
+    }
+
+    if (!configService().shouldIndex(uid)) {
+      throw new Error('This content type is not configured for Algolia indexing');
+    }
+
+    const cfg = configService().getConfig(uid);
+    if (!cfg || cfg.isSingleType) {
+      throw new Error('Not an indexable collection type');
+    }
+
+    const populate = buildPopulate(uid);
+    let total = 0;
+    const PAGE_SIZE = 100;
+    let start = 0;
+    let hasMore = true;
+
+    while (hasMore) {
+      const entries = await strapi
+        .documents(/** @type {any} */ (uid))
+        .findMany({ populate, status: 'published', limit: PAGE_SIZE, start });
+
+      if (!entries || entries.length === 0) {
+        hasMore = false;
+        break;
+      }
+
+      const objects = entries.map((entry) =>
+        buildRecord(entry, schema, cfg, uid, entry.documentId, entry.locale)
+      );
+
+      await clientService().saveObjects(cfg.indexName, objects);
+      total += entries.length;
+      start += entries.length;
+      if (entries.length < PAGE_SIZE) hasMore = false;
+    }
+
+    strapi.log.info(
+      `[Algolia] Bulk reindex ${uid} → ${cfg.indexName} (${total} documents)`
+    );
+
+    return { count: total, indexName: cfg.indexName };
+  }
+
+  /** Reindex every configured content type. */
+  async function fullReindex() {
+    if (!clientService().getClient()) {
+      strapi.log.warn('[Algolia] Skipping full reindex — client not configured');
+      return;
+    }
+
+    strapi.log.info('[Algolia] Starting full reindex …');
+    const uids = configService().getAllIndexableUIDs();
+
+    for (const uid of uids) {
+      const cfg = configService().getConfig(uid);
+      if (!cfg) continue;
+
+      const schema = strapi.contentTypes[uid];
+      const populate = buildPopulate(uid);
+
+      try {
+        const PAGE_SIZE = 100;
+        let start = 0;
+        let hasMore = true;
+
+        while (hasMore) {
+          const entries = await strapi
+            .documents(/** @type {any} */ (uid))
+            .findMany({ populate, status: 'published', limit: PAGE_SIZE, start });
+
+          if (!entries || entries.length === 0) {
+            hasMore = false;
+            break;
+          }
+
+          const objects = entries.map((entry) =>
+            buildRecord(entry, schema, cfg, uid, entry.documentId, entry.locale)
+          );
+
+          await clientService().saveObjects(cfg.indexName, objects);
+          start += entries.length;
+          if (entries.length < PAGE_SIZE) hasMore = false;
+        }
+
+        strapi.log.info(`[Algolia] Reindexed ${uid}`);
+      } catch (err) {
+        strapi.log.error(`[Algolia] Reindex error for ${uid}: ${err.message}`);
+      }
+    }
+
+    strapi.log.info('[Algolia] Full reindex complete');
+  }
+
+  return {
+    indexEntry,
+    removeEntry,
+    reindexCollectionUid,
+    fullReindex,
+  };
+};

package/server/services/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports = {
+  algoliaClient: require('./algolia-client'),
+  algoliaConfig: require('./algolia-config'),
+  algoliaSync: require('./algolia-sync'),
+};

package/strapi-admin.js

@@ -0,0 +1 @@
+export { default } from './admin/src/index';

package/strapi-server.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./server');