@littlebearapps/platform-admin-sdk 2.0.0 → 2.1.0

package/templates/full/dashboard/src/lib/search/api.ts

@@ -0,0 +1,258 @@
+/**
+ * Search API Client
+ *
+ * Functions for interacting with the platform-search worker.
+ * Used by dashboard components for platform-wide search.
+ *
+ * @module dashboard/lib/search/api
+ * @created 2026-02-03
+ * @task task-303.1
+ */
+
+import type {
+  SearchResponse,
+  SearchStatsResponse,
+  IndexDocumentRequest,
+  BulkIndexRequest,
+  BulkIndexResponse,
+  SearchQueryParams,
+  SearchContentType,
+  ContentTypeConfig,
+} from './types';
+
+/** Base URL for search API (via service binding proxy) */
+const API_BASE = '/api/search';
+
+/**
+ * Perform a search query
+ */
+export async function search(params: SearchQueryParams): Promise<SearchResponse> {
+  const searchParams = new URLSearchParams();
+  searchParams.set('q', params.q);
+  if (params.type) searchParams.set('type', params.type);
+  if (params.project) searchParams.set('project', params.project);
+  if (params.limit) searchParams.set('limit', String(params.limit));
+  if (params.offset) searchParams.set('offset', String(params.offset));
+
+  const url = `${API_BASE}?${searchParams.toString()}`;
+  const response = await fetch(url);
+
+  if (!response.ok) {
+    throw new Error(`Search failed: ${response.statusText}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Index a single document
+ */
+export async function indexDocument(
+  doc: IndexDocumentRequest
+): Promise<{ success: boolean; id: string }> {
+  const response = await fetch(`${API_BASE}/index`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(doc),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to index document: ${response.statusText}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Bulk index multiple documents
+ */
+export async function bulkIndexDocuments(data: BulkIndexRequest): Promise<BulkIndexResponse> {
+  const response = await fetch(`${API_BASE}/index/bulk`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(data),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Bulk index failed: ${response.statusText}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Clear and reindex all documents of a content type
+ */
+export async function reindexContentType(
+  contentType: SearchContentType
+): Promise<{ success: boolean; content_type: string; deleted: number; message: string }> {
+  const response = await fetch(`${API_BASE}/reindex/${contentType}`, {
+    method: 'POST',
+  });
+
+  if (!response.ok) {
+    throw new Error(`Reindex failed: ${response.statusText}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Delete a document from the index
+ */
+export async function deleteDocument(id: string): Promise<{ success: boolean; deleted: string }> {
+  const response = await fetch(`${API_BASE}/index/${encodeURIComponent(id)}`, {
+    method: 'DELETE',
+  });
+
+  if (!response.ok) {
+    if (response.status === 404) {
+      throw new Error(`Document not found: ${id}`);
+    }
+    throw new Error(`Failed to delete document: ${response.statusText}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Get search index statistics
+ */
+export async function getSearchStats(): Promise<SearchStatsResponse> {
+  const response = await fetch(`${API_BASE}/stats`);
+
+  if (!response.ok) {
+    throw new Error(`Failed to fetch search stats: ${response.statusText}`);
+  }
+
+  return response.json();
+}
+
+/** Content type configuration for UI display */
+export const CONTENT_TYPE_CONFIG: Record<SearchContentType, ContentTypeConfig> = {
+  error: {
+    label: 'Errors',
+    icon: 'alert-circle',
+    color: 'text-red-500 dark:text-red-400',
+  },
+  pattern: {
+    label: 'Patterns',
+    icon: 'cpu',
+    color: 'text-purple-500 dark:text-purple-400',
+  },
+  setting: {
+    label: 'Settings',
+    icon: 'settings',
+    color: 'text-gray-500 dark:text-gray-400',
+  },
+  page: {
+    label: 'Pages',
+    icon: 'file-text',
+    color: 'text-blue-500 dark:text-blue-400',
+  },
+  service: {
+    label: 'Services',
+    icon: 'server',
+    color: 'text-green-500 dark:text-green-400',
+  },
+  opportunity: {
+    label: 'Opportunities',
+    icon: 'target',
+    color: 'text-orange-500 dark:text-orange-400',
+  },
+  draft: {
+    label: 'Drafts',
+    icon: 'edit',
+    color: 'text-cyan-500 dark:text-cyan-400',
+  },
+  project: {
+    label: 'Projects',
+    icon: 'folder',
+    color: 'text-indigo-500 dark:text-indigo-400',
+  },
+};
+
+/**
+ * Get content type configuration
+ */
+export function getContentTypeConfig(contentType: SearchContentType): ContentTypeConfig {
+  return (
+    CONTENT_TYPE_CONFIG[contentType] || {
+      label: contentType,
+      icon: 'file',
+      color: 'text-gray-500',
+    }
+  );
+}
+
+/**
+ * Highlight search terms in text
+ */
+export function highlightSearchTerms(text: string, query: string): string {
+  if (!query.trim()) return text;
+
+  const terms = query
+    .toLowerCase()
+    .split(/\s+/)
+    .filter((t) => t.length > 2);
+
+  if (terms.length === 0) return text;
+
+  // Create regex pattern for all terms
+  const pattern = new RegExp(`(${terms.map(escapeRegex).join('|')})`, 'gi');
+
+  return text.replace(
+    pattern,
+    '<mark class="bg-yellow-200 dark:bg-yellow-800 rounded px-0.5">$1</mark>'
+  );
+}
+
+/**
+ * Escape special regex characters
+ */
+function escapeRegex(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/**
+ * Store recent searches in localStorage
+ */
+export function addRecentSearch(query: string): void {
+  if (typeof window === 'undefined') return;
+
+  const key = 'platform-search-recent';
+  const maxRecent = 10;
+
+  try {
+    const existing = JSON.parse(localStorage.getItem(key) || '[]') as string[];
+    const filtered = existing.filter((q) => q !== query);
+    const updated = [query, ...filtered].slice(0, maxRecent);
+    localStorage.setItem(key, JSON.stringify(updated));
+  } catch {
+    // Ignore localStorage errors
+  }
+}
+
+/**
+ * Get recent searches from localStorage
+ */
+export function getRecentSearches(): string[] {
+  if (typeof window === 'undefined') return [];
+
+  const key = 'platform-search-recent';
+
+  try {
+    return JSON.parse(localStorage.getItem(key) || '[]') as string[];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Clear recent searches
+ */
+export function clearRecentSearches(): void {
+  if (typeof window === 'undefined') return;
+
+  localStorage.removeItem('platform-search-recent');
+}

package/templates/full/dashboard/src/lib/search/types.ts.hbs

@@ -0,0 +1,115 @@
+/**
+ * Search Types
+ *
+ * TypeScript types for the platform search system.
+ *
+ * @module dashboard/lib/search/types
+ */
+
+/** Valid content types for search */
+export type SearchContentType =
+  | 'error'
+  | 'pattern'
+  | 'setting'
+  | 'page'
+  | 'service'
+  | 'project';
+
+/** Project scope for search results */
+export type SearchProject = 'platform' | '{{projectSlug}}' | null;
+
+/** A search document in the index */
+export interface SearchDocument {
+  id: string;
+  content_type: SearchContentType;
+  project: SearchProject;
+  title: string;
+  content: string;
+  url: string;
+  metadata: string | null;
+  indexed_at: number;
+  source_updated_at: number | null;
+}
+
+/** A search result with ranking and snippet */
+export interface SearchResult extends SearchDocument {
+  rank: number;
+  snippet: string;
+  parsed_metadata?: Record<string, unknown>;
+}
+
+/** Search results grouped by content type */
+export interface GroupedSearchResults {
+  [contentType: string]: SearchResult[];
+}
+
+/** Search response */
+export interface SearchResponse {
+  results: SearchResult[];
+  grouped: GroupedSearchResults;
+  count: number;
+  query: string;
+  filters: {
+    type: SearchContentType | null;
+    project: string | null;
+  };
+  error?: string;
+}
+
+/** Request to index a document */
+export interface IndexDocumentRequest {
+  id: string;
+  content_type: SearchContentType;
+  project?: SearchProject;
+  title: string;
+  content: string;
+  url: string;
+  metadata?: Record<string, unknown>;
+  source_updated_at?: number;
+}
+
+/** Bulk index request */
+export interface BulkIndexRequest {
+  documents: IndexDocumentRequest[];
+}
+
+/** Bulk index response */
+export interface BulkIndexResponse {
+  success: boolean;
+  indexed: number;
+  failed: number;
+  total: number;
+}
+
+/** Index statistics response */
+export interface SearchStatsResponse {
+  total: number;
+  by_type: Array<{
+    content_type: string;
+    count: number;
+  }>;
+  by_project: Array<{
+    project: string;
+    count: number;
+  }>;
+  index_range: {
+    oldest: string | null;
+    newest: string | null;
+  };
+}
+
+/** Query parameters for search */
+export interface SearchQueryParams {
+  q: string;
+  type?: SearchContentType;
+  project?: string;
+  limit?: number;
+  offset?: number;
+}
+
+/** Content type configuration for UI */
+export interface ContentTypeConfig {
+  label: string;
+  icon: string;
+  color: string;
+}

package/templates/full/dashboard/src/lib/settings/api.ts.hbs

@@ -0,0 +1,201 @@
+/**
+ * Settings API Client
+ *
+ * Functions for interacting with the platform-settings worker.
+ * Used by dashboard components to read and update settings.
+ *
+ * @module dashboard/lib/settings/api
+ */
+
+import type {
+  Setting,
+  ParsedSetting,
+  SettingsListResponse,
+  CategorySettingsResponse,
+  UpdateSettingRequest,
+  BulkUpdateRequest,
+  BulkUpdateResponse,
+  SettingsQueryParams,
+  SettingsProject,
+  SettingsCategory,
+} from './types';
+
+/** Base URL for settings API (via service binding proxy) */
+const API_BASE = '/api/settings';
+
+/**
+ * Fetch all settings with optional filters
+ */
+export async function getSettings(params: SettingsQueryParams = {}): Promise<SettingsListResponse> {
+  const searchParams = new URLSearchParams();
+  if (params.project) searchParams.set('project', params.project);
+  if (params.category) searchParams.set('category', params.category);
+
+  const url = searchParams.toString() ? `${API_BASE}?${searchParams.toString()}` : API_BASE;
+  const response = await fetch(url);
+
+  if (!response.ok) {
+    throw new Error(`Failed to fetch settings: ${response.statusText}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Get settings for a specific project and category
+ */
+export async function getCategorySettings(
+  project: SettingsProject,
+  category: SettingsCategory
+): Promise<CategorySettingsResponse> {
+  const response = await fetch(`${API_BASE}/${project}/${category}`);
+
+  if (!response.ok) {
+    throw new Error(`Failed to fetch category settings: ${response.statusText}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Get a single setting by project, category, and key
+ */
+export async function getSetting(
+  project: SettingsProject,
+  category: SettingsCategory,
+  key: string
+): Promise<ParsedSetting> {
+  const response = await fetch(`${API_BASE}/${project}/${category}/${key}`);
+
+  if (!response.ok) {
+    if (response.status === 404) {
+      throw new Error(`Setting not found: ${project}/${category}/${key}`);
+    }
+    throw new Error(`Failed to fetch setting: ${response.statusText}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Update a setting
+ */
+export async function updateSetting(
+  project: SettingsProject,
+  category: SettingsCategory,
+  key: string,
+  data: UpdateSettingRequest
+): Promise<Setting> {
+  const response = await fetch(`${API_BASE}/${project}/${category}/${key}`, {
+    method: 'PUT',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(data),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to update setting: ${response.statusText}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Delete a setting
+ */
+export async function deleteSetting(
+  project: SettingsProject,
+  category: SettingsCategory,
+  key: string
+): Promise<{ success: boolean; deleted: string }> {
+  const response = await fetch(`${API_BASE}/${project}/${category}/${key}`, {
+    method: 'DELETE',
+  });
+
+  if (!response.ok) {
+    if (response.status === 404) {
+      throw new Error(`Setting not found: ${project}/${category}/${key}`);
+    }
+    throw new Error(`Failed to delete setting: ${response.statusText}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Bulk update multiple settings
+ */
+export async function bulkUpdateSettings(data: BulkUpdateRequest): Promise<BulkUpdateResponse> {
+  const response = await fetch(`${API_BASE}/bulk`, {
+    method: 'PUT',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(data),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to bulk update settings: ${response.statusText}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Parse a JSON-encoded setting value with type safety
+ */
+export function parseSettingValue<T>(setting: Setting, defaultValue: T): T {
+  try {
+    const parsed = JSON.parse(setting.value);
+    return parsed as T;
+  } catch {
+    return defaultValue;
+  }
+}
+
+/**
+ * Get project display name
+ */
+export function getProjectDisplayName(project: SettingsProject): string {
+  switch (project) {
+    case 'global':
+      return 'Global';
+    case 'platform':
+      return 'Platform';
+    case '{{projectSlug}}':
+      return '{{projectName}}';
+    default:
+      return project;
+  }
+}
+
+/**
+ * Get category display name
+ */
+export function getCategoryDisplayName(category: SettingsCategory): string {
+  switch (category) {
+    case 'notifications':
+      return 'Notifications';
+    case 'thresholds':
+      return 'Thresholds';
+    case 'display':
+      return 'Display';
+    case 'api':
+      return 'API';
+    case 'features':
+      return 'Features';
+    default:
+      return category;
+  }
+}
+
+/**
+ * Format updated timestamp for display
+ */
+export function formatUpdatedAt(timestamp: number): string {
+  const date = new Date(timestamp * 1000);
+  return date.toLocaleDateString('en-AU', {
+    day: 'numeric',
+    month: 'short',
+    year: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+  });
+}

package/templates/full/dashboard/src/lib/settings/types.ts.hbs

@@ -0,0 +1,104 @@
+/**
+ * Settings Types
+ *
+ * TypeScript types for the platform settings system.
+ *
+ * @module dashboard/lib/settings/types
+ */
+
+/** Valid project scopes for settings */
+export type SettingsProject = 'global' | 'platform' | '{{projectSlug}}';
+
+/** Valid setting categories */
+export type SettingsCategory = 'notifications' | 'thresholds' | 'display' | 'api' | 'features';
+
+/** A single setting */
+export interface Setting {
+  id: string;
+  project: SettingsProject;
+  category: SettingsCategory;
+  key: string;
+  value: string; // JSON-encoded
+  description: string | null;
+  updated_at: number;
+  updated_by: string | null;
+}
+
+/** Setting with parsed value */
+export interface ParsedSetting extends Setting {
+  parsed_value: unknown;
+}
+
+/** Settings grouped by project and category */
+export interface GroupedSettings {
+  [project: string]: {
+    [category: string]: Setting[];
+  };
+}
+
+/** Settings list response */
+export interface SettingsListResponse {
+  settings: Setting[];
+  grouped: GroupedSettings;
+  count: number;
+}
+
+/** Settings for a specific project/category */
+export interface CategorySettingsResponse {
+  project: SettingsProject;
+  category: SettingsCategory;
+  settings: ParsedSetting[];
+  count: number;
+}
+
+/** Request to update a setting */
+export interface UpdateSettingRequest {
+  value: unknown;
+  description?: string;
+}
+
+/** Bulk update request */
+export interface BulkUpdateRequest {
+  settings: Array<{
+    project: SettingsProject;
+    category: SettingsCategory;
+    key: string;
+    value: unknown;
+    description?: string;
+  }>;
+}
+
+/** Bulk update response */
+export interface BulkUpdateResponse {
+  success: boolean;
+  total: number;
+  succeeded: number;
+  failed: number;
+  results: Array<{
+    id: string;
+    success: boolean;
+    error?: string;
+  }>;
+}
+
+/** Query parameters for listing settings */
+export interface SettingsQueryParams {
+  project?: SettingsProject;
+  category?: SettingsCategory;
+}
+
+/** Common global settings */
+export interface GlobalNotificationSettings {
+  email_enabled: boolean;
+  slack_enabled: boolean;
+  digest_frequency: 'realtime' | 'hourly' | 'daily' | 'weekly';
+}
+
+export interface GlobalThresholdSettings {
+  warning_percent: number;
+  critical_percent: number;
+}
+
+export interface GlobalDisplaySettings {
+  dark_mode: 'system' | 'light' | 'dark';
+}