@commonpub/layer 0.3.30 → 0.3.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@commonpub/layer",
-  "version": "0.3.30",
+  "version": "0.3.32",
   "type": "module",
   "main": "./nuxt.config.ts",
   "files": [
@@ -45,13 +45,13 @@
     "vue-router": "^4.3.0",
     "zod": "^4.3.6",
     "@commonpub/auth": "0.5.0",
-    "@commonpub/docs": "0.5.2",
     "@commonpub/config": "0.7.1",
-    "@commonpub/learning": "0.5.0",
+    "@commonpub/docs": "0.5.2",
     "@commonpub/editor": "0.5.0",
+    "@commonpub/learning": "0.5.0",
     "@commonpub/protocol": "0.9.5",
     "@commonpub/schema": "0.8.13",
-    "@commonpub/server": "2.18.0",
+    "@commonpub/server": "2.19.0",
     "@commonpub/ui": "0.7.1"
   },
   "devDependencies": {

package/pages/search.vue

@@ -75,24 +75,31 @@ const { data: results, status } = await useFetch<PaginatedResponse<Serialized<Co
 
 const resultCount = computed(() => results.value?.total ?? results.value?.items?.length ?? 0);
 
-// Federated search
+// Federated search — uses server-side Postgres FTS
 const fedResults = ref<any[]>([]);
 const fedLoading = ref(false);
 watch([query, activeType], async () => {
   if (activeType.value !== 'fediverse' || !query.value) { fedResults.value = []; return; }
   fedLoading.value = true;
   try {
-    const data = await $fetch<{ items: any[]; total: number }>('/api/federation/timeline', {
-      params: { limit: 20 },
+    const data = await $fetch<{ items: any[]; total: number }>('/api/search/federated', {
+      params: { q: query.value, limit: 20 },
     });
-    // Client-side filter by query since the timeline endpoint doesn't have search
-    const q = query.value.toLowerCase();
-    fedResults.value = data.items.filter((item: any) =>
-      (item.title?.toLowerCase().includes(q)) ||
-      (item.content?.toLowerCase().includes(q)) ||
-      (item.summary?.toLowerCase().includes(q))
-    );
-  } catch { fedResults.value = []; }
+    fedResults.value = data.items;
+  } catch {
+    // Fallback: if federated search endpoint not available, try client-side
+    try {
+      const data = await $fetch<{ items: any[]; total: number }>('/api/federation/timeline', {
+        params: { limit: 40 },
+      });
+      const q = query.value.toLowerCase();
+      fedResults.value = data.items.filter((item: any) =>
+        (item.title?.toLowerCase().includes(q)) ||
+        (item.content?.toLowerCase().includes(q)) ||
+        (item.summary?.toLowerCase().includes(q))
+      );
+    } catch { fedResults.value = []; }
+  }
   fedLoading.value = false;
 }, { immediate: true });
 

package/server/api/search/federated.get.ts

@@ -0,0 +1,20 @@
+import { searchFederatedContent } from '@commonpub/server';
+import { z } from 'zod';
+
+const schema = z.object({
+  q: z.string().max(200),
+  limit: z.coerce.number().int().positive().max(100).optional(),
+  offset: z.coerce.number().int().min(0).optional(),
+});
+
+/**
+ * Server-side federated content search using Postgres FTS.
+ * Replaces the client-side filtering on /api/federation/timeline.
+ */
+export default defineEventHandler(async (event) => {
+  requireFeature('federation');
+  const db = useDB();
+  const { q, limit, offset } = parseQueryParams(event, schema);
+
+  return searchFederatedContent(db, q, { limit, offset });
+});

package/server/api/search/index.get.ts

@@ -1,24 +1,54 @@
-import { listContent } from '@commonpub/server';
-import type { PaginatedResponse, ContentListItem } from '@commonpub/server';
-import { contentFiltersSchema } from '@commonpub/schema';
+import { searchContent } from '@commonpub/server';
+import type { ContentSearchResult, ContentSearchOptions } from '@commonpub/server';
 import { z } from 'zod';
 
-const searchQuerySchema = contentFiltersSchema.extend({
+const searchQuerySchema = z.object({
   q: z.string().max(200).optional(),
+  type: z.string().optional(),
+  sort: z.enum(['relevance', 'recent', 'popular']).optional(),
+  difficulty: z.string().optional(),
+  tags: z.string().optional(),
+  author: z.string().optional(),
+  dateFrom: z.string().optional(),
+  dateTo: z.string().optional(),
+  limit: z.coerce.number().int().positive().max(100).optional(),
+  offset: z.coerce.number().int().min(0).optional(),
 });
 
-export default defineEventHandler(async (event): Promise<PaginatedResponse<ContentListItem>> => {
+export default defineEventHandler(async (event): Promise<{ items: ContentSearchResult[]; total: number }> => {
   const db = useDB();
-  const filters = parseQueryParams(event, searchQuerySchema);
-  const q = filters.q || filters.search;
+  const params = parseQueryParams(event, searchQuerySchema);
+  const q = params.q?.trim();
 
   if (!q) {
     return { items: [], total: 0 };
   }
 
-  return listContent(db, {
-    ...filters,
-    status: 'published',
-    search: q,
-  });
+  // Get Meilisearch client if configured
+  let meiliClient = null;
+  try {
+    const meiliUrl = process.env.MEILI_URL;
+    const meiliKey = process.env.MEILI_MASTER_KEY;
+    if (meiliUrl) {
+      const { MeiliSearch } = await import('meilisearch');
+      meiliClient = new MeiliSearch({ host: meiliUrl, apiKey: meiliKey });
+    }
+  } catch {
+    // Meilisearch not available — will use Postgres fallback
+  }
+
+  const opts: ContentSearchOptions = {
+    query: q,
+    type: params.type,
+    difficulty: params.difficulty,
+    tags: params.tags?.split(',').map(t => t.trim()).filter(Boolean),
+    authorUsername: params.author,
+    dateFrom: params.dateFrom,
+    dateTo: params.dateTo,
+    sort: (params.sort as ContentSearchOptions['sort']) ?? 'relevance',
+    limit: params.limit,
+    offset: params.offset,
+  };
+
+  return searchContent(db, opts, meiliClient);
 });

package/server/plugins/search-index.ts

@@ -0,0 +1,57 @@
+/**
+ * Search indexing plugin.
+ * Keeps Meilisearch in sync with content changes via hooks.
+ * If Meilisearch is not configured, this plugin is a no-op.
+ */
+import { onHook, indexContent, removeFromIndex, configureContentIndex } from '@commonpub/server';
+import type { MeiliClient } from '@commonpub/server';
+
+export default defineNitroPlugin(async () => {
+  if (process.env.NODE_ENV === 'test') return;
+
+  const meiliUrl = process.env.MEILI_URL;
+  const meiliKey = process.env.MEILI_MASTER_KEY;
+
+  if (!meiliUrl) {
+    console.log('[search-index] Meilisearch not configured — search uses Postgres FTS fallback');
+    return;
+  }
+
+  let client: MeiliClient;
+  try {
+    const { MeiliSearch } = await import('meilisearch');
+    client = new MeiliSearch({ host: meiliUrl, apiKey: meiliKey }) as unknown as MeiliClient;
+    await configureContentIndex(client);
+    console.log('[search-index] Meilisearch content index configured');
+  } catch (err) {
+    console.warn('[search-index] Failed to connect to Meilisearch:', err instanceof Error ? err.message : err);
+    return;
+  }
+
+  // Index on publish
+  onHook('content:published', async ({ db, contentId }) => {
+    try {
+      await indexContent(db, contentId, client);
+    } catch (err) {
+      console.warn('[search-index] Failed to index content:', err instanceof Error ? err.message : err);
+    }
+  });
+
+  // Re-index on update
+  onHook('content:updated', async ({ db, contentId }) => {
+    try {
+      await indexContent(db, contentId, client);
+    } catch (err) {
+      console.warn('[search-index] Failed to re-index content:', err instanceof Error ? err.message : err);
+    }
+  });
+
+  // Remove from index on delete
+  onHook('content:deleted', async ({ contentId }) => {
+    try {
+      await removeFromIndex(contentId, client);
+    } catch (err) {
+      console.warn('[search-index] Failed to remove from index:', err instanceof Error ? err.message : err);
+    }
+  });
+});