servcraft 0.1.0 → 0.1.3

package/src/modules/search/adapters/memory.adapter.ts

@@ -0,0 +1,278 @@
+import type {
+  SearchEngine,
+  SearchDocument,
+  SearchQuery,
+  SearchResult,
+  IndexSettings,
+  BulkIndexOperation,
+  BulkIndexResult,
+  IndexStats,
+  AutocompleteResult,
+} from '../types.js';
+
+interface IndexData {
+  documents: Map<string, SearchDocument>;
+  settings: IndexSettings;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+/**
+ * In-Memory Search Adapter
+ * For development and testing
+ */
+export class MemorySearchAdapter implements SearchEngine {
+  private indexes = new Map<string, IndexData>();
+
+  async createIndex(indexName: string, settings?: IndexSettings): Promise<void> {
+    this.indexes.set(indexName, {
+      documents: new Map(),
+      settings: settings || {},
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+  }
+
+  async deleteIndex(indexName: string): Promise<void> {
+    this.indexes.delete(indexName);
+  }
+
+  async index(indexName: string, id: string, document: SearchDocument): Promise<void> {
+    if (!this.indexes.has(indexName)) {
+      await this.createIndex(indexName);
+    }
+
+    const index = this.indexes.get(indexName)!;
+    index.documents.set(id, { ...document, id });
+    index.updatedAt = new Date();
+  }
+
+  async bulkIndex(indexName: string, operations: BulkIndexOperation[]): Promise<BulkIndexResult> {
+    const startTime = Date.now();
+    let success = 0;
+    let failed = 0;
+    const errors: Array<{ id: string; error: string }> = [];
+
+    for (const op of operations) {
+      try {
+        if (op.operation === 'index' || op.operation === 'update') {
+          if (op.document) {
+            await this.index(indexName, op.id, op.document);
+            success++;
+          }
+        } else if (op.operation === 'delete') {
+          await this.delete(indexName, op.id);
+          success++;
+        }
+      } catch (error) {
+        failed++;
+        errors.push({
+          id: op.id,
+          error: error instanceof Error ? error.message : 'Unknown error',
+        });
+      }
+    }
+
+    return {
+      success,
+      failed,
+      errors: errors.length > 0 ? errors : undefined,
+      processingTime: Date.now() - startTime,
+    };
+  }
+
+  async search<T = SearchDocument>(
+    indexName: string,
+    query: SearchQuery
+  ): Promise<SearchResult<T>> {
+    const startTime = Date.now();
+    const index = this.indexes.get(indexName);
+
+    if (!index) {
+      return {
+        hits: [],
+        total: 0,
+        processingTime: Date.now() - startTime,
+      };
+    }
+
+    let documents = Array.from(index.documents.values());
+
+    // Simple text search
+    if (query.query) {
+      const searchTerms = query.query.toLowerCase().split(' ');
+      documents = documents.filter((doc) => {
+        const searchableFields = query.fields || index.settings.searchableAttributes || [];
+        const allFields = searchableFields.length > 0 ? searchableFields : Object.keys(doc);
+
+        return allFields.some((field) => {
+          const value = String(doc[field] || '').toLowerCase();
+          return searchTerms.some((term) => value.includes(term));
+        });
+      });
+    }
+
+    // Apply filters
+    if (query.filters) {
+      for (const filter of query.filters) {
+        documents = documents.filter((doc) => {
+          const value = doc[filter.field];
+
+          switch (filter.operator) {
+            case 'eq':
+              return value === filter.value;
+            case 'ne':
+              return value !== filter.value;
+            case 'gt':
+              return Number(value) > Number(filter.value);
+            case 'gte':
+              return Number(value) >= Number(filter.value);
+            case 'lt':
+              return Number(value) < Number(filter.value);
+            case 'lte':
+              return Number(value) <= Number(filter.value);
+            case 'in':
+              return Array.isArray(filter.value) && filter.value.includes(value);
+            case 'contains':
+              return String(value).toLowerCase().includes(String(filter.value).toLowerCase());
+            case 'exists':
+              return value !== undefined && value !== null;
+            default:
+              return true;
+          }
+        });
+      }
+    }
+
+    // Apply sorting
+    if (query.sort && query.sort.length > 0) {
+      documents.sort((a, b) => {
+        for (const sort of query.sort!) {
+          const aVal = a[sort.field];
+          const bVal = b[sort.field];
+
+          if (aVal === bVal) continue;
+
+          // Compare values handling different types
+          const aNum = typeof aVal === 'number' ? aVal : String(aVal ?? '');
+          const bNum = typeof bVal === 'number' ? bVal : String(bVal ?? '');
+          const comparison = aNum > bNum ? 1 : -1;
+          return sort.direction === 'asc' ? comparison : -comparison;
+        }
+        return 0;
+      });
+    }
+
+    const total = documents.length;
+
+    // Pagination
+    const offset = query.offset || 0;
+    const limit = query.limit || 20;
+    const paginatedDocs = documents.slice(offset, offset + limit);
+
+    // Build hits
+    const hits = paginatedDocs.map((doc) => ({
+      document: doc as T,
+      score: 1.0,
+    }));
+
+    return {
+      hits,
+      total,
+      processingTime: Date.now() - startTime,
+      page: Math.floor(offset / limit) + 1,
+      totalPages: Math.ceil(total / limit),
+    };
+  }
+
+  async delete(indexName: string, id: string): Promise<void> {
+    const index = this.indexes.get(indexName);
+    if (index) {
+      index.documents.delete(id);
+      index.updatedAt = new Date();
+    }
+  }
+
+  async update(indexName: string, id: string, document: Partial<SearchDocument>): Promise<void> {
+    const index = this.indexes.get(indexName);
+    if (!index) {
+      throw new Error('Index not found');
+    }
+
+    const existing = index.documents.get(id);
+    if (!existing) {
+      throw new Error('Document not found');
+    }
+
+    index.documents.set(id, { ...existing, ...document });
+    index.updatedAt = new Date();
+  }
+
+  async get(indexName: string, id: string): Promise<SearchDocument | null> {
+    const index = this.indexes.get(indexName);
+    return index?.documents.get(id) || null;
+  }
+
+  async updateSettings(indexName: string, settings: IndexSettings): Promise<void> {
+    const index = this.indexes.get(indexName);
+    if (!index) {
+      throw new Error('Index not found');
+    }
+
+    index.settings = { ...index.settings, ...settings };
+    index.updatedAt = new Date();
+  }
+
+  async getStats(indexName: string): Promise<IndexStats> {
+    const index = this.indexes.get(indexName);
+
+    if (!index) {
+      throw new Error('Index not found');
+    }
+
+    const docsSize = JSON.stringify(Array.from(index.documents.values())).length;
+
+    return {
+      name: indexName,
+      documentCount: index.documents.size,
+      size: docsSize,
+      isIndexing: false,
+      lastUpdate: index.updatedAt,
+      health: 'green',
+    };
+  }
+
+  async autocomplete(indexName: string, query: string, limit = 10): Promise<AutocompleteResult> {
+    const startTime = Date.now();
+    const index = this.indexes.get(indexName);
+
+    if (!index) {
+      return {
+        suggestions: [],
+        processingTime: Date.now() - startTime,
+      };
+    }
+
+    const queryLower = query.toLowerCase();
+    const suggestions = new Set<string>();
+
+    for (const doc of index.documents.values()) {
+      const searchableFields = index.settings.searchableAttributes || Object.keys(doc);
+
+      for (const field of searchableFields) {
+        const value = String(doc[field] || '');
+        if (value.toLowerCase().includes(queryLower)) {
+          suggestions.add(value);
+          if (suggestions.size >= limit) break;
+        }
+      }
+
+      if (suggestions.size >= limit) break;
+    }
+
+    return {
+      suggestions: Array.from(suggestions).slice(0, limit),
+      processingTime: Date.now() - startTime,
+    };
+  }
+}

package/src/modules/search/index.ts

@@ -0,0 +1,21 @@
+export { SearchService } from './search.service.js';
+export { MemorySearchAdapter } from './adapters/memory.adapter.js';
+export { ElasticsearchAdapter } from './adapters/elasticsearch.adapter.js';
+export { MeilisearchAdapter } from './adapters/meilisearch.adapter.js';
+export type {
+  SearchConfig,
+  SearchDocument,
+  SearchQuery,
+  SearchResult,
+  SearchHit,
+  SearchFilter,
+  SearchSort,
+  IndexSettings,
+  BulkIndexOperation,
+  BulkIndexResult,
+  IndexStats,
+  AutocompleteResult,
+  FacetResult,
+  SearchSuggestion,
+  SearchEngine,
+} from './types.js';

package/src/modules/search/search.service.ts

@@ -0,0 +1,234 @@
+import { logger } from '../../core/logger.js';
+import { NotFoundError } from '../../utils/errors.js';
+import type {
+  SearchConfig,
+  SearchDocument,
+  SearchQuery,
+  SearchResult,
+  IndexSettings,
+  BulkIndexOperation,
+  BulkIndexResult,
+  IndexStats,
+  AutocompleteResult,
+  SearchEngine,
+} from './types.js';
+import { MemorySearchAdapter } from './adapters/memory.adapter.js';
+
+/**
+ * Search Service
+ * Unified interface for Elasticsearch, Meilisearch, or in-memory search
+ */
+export class SearchService {
+  private engine: SearchEngine;
+  private config: SearchConfig;
+
+  constructor(config?: SearchConfig, engine?: SearchEngine) {
+    this.config = config || {};
+    this.engine = engine || new MemorySearchAdapter();
+
+    logger.info({ engine: this.config.engine || 'memory' }, 'Search service initialized');
+  }
+
+  /**
+   * Create a search index
+   */
+  async createIndex(indexName: string, settings?: IndexSettings): Promise<void> {
+    const mergedSettings = {
+      ...this.config.defaultSettings,
+      ...settings,
+    };
+
+    await this.engine.createIndex(indexName, mergedSettings);
+
+    logger.info({ indexName, settings: mergedSettings }, 'Search index created');
+  }
+
+  /**
+   * Delete a search index
+   */
+  async deleteIndex(indexName: string): Promise<void> {
+    await this.engine.deleteIndex(indexName);
+
+    logger.info({ indexName }, 'Search index deleted');
+  }
+
+  /**
+   * Index a single document
+   */
+  async indexDocument(indexName: string, id: string, document: SearchDocument): Promise<void> {
+    await this.engine.index(indexName, id, document);
+
+    logger.debug({ indexName, documentId: id }, 'Document indexed');
+  }
+
+  /**
+   * Index multiple documents
+   */
+  async indexDocuments(indexName: string, documents: SearchDocument[]): Promise<BulkIndexResult> {
+    const operations: BulkIndexOperation[] = documents.map((doc) => ({
+      operation: 'index',
+      id: doc.id,
+      document: doc,
+    }));
+
+    const result = await this.engine.bulkIndex(indexName, operations);
+
+    logger.info(
+      { indexName, success: result.success, failed: result.failed },
+      'Bulk index completed'
+    );
+
+    return result;
+  }
+
+  /**
+   * Search documents
+   */
+  async search<T = SearchDocument>(
+    indexName: string,
+    query: SearchQuery
+  ): Promise<SearchResult<T>> {
+    const startTime = Date.now();
+
+    const result = await this.engine.search<T>(indexName, query);
+
+    const duration = Date.now() - startTime;
+
+    logger.debug(
+      {
+        indexName,
+        query: query.query,
+        hits: result.hits.length,
+        total: result.total,
+        duration,
+      },
+      'Search completed'
+    );
+
+    return result;
+  }
+
+  /**
+   * Delete a document
+   */
+  async deleteDocument(indexName: string, id: string): Promise<void> {
+    await this.engine.delete(indexName, id);
+
+    logger.debug({ indexName, documentId: id }, 'Document deleted');
+  }
+
+  /**
+   * Update a document
+   */
+  async updateDocument(
+    indexName: string,
+    id: string,
+    document: Partial<SearchDocument>
+  ): Promise<void> {
+    await this.engine.update(indexName, id, document);
+
+    logger.debug({ indexName, documentId: id }, 'Document updated');
+  }
+
+  /**
+   * Get document by ID
+   */
+  async getDocument(indexName: string, id: string): Promise<SearchDocument> {
+    const doc = await this.engine.get(indexName, id);
+
+    if (!doc) {
+      throw new NotFoundError('Document not found');
+    }
+
+    return doc;
+  }
+
+  /**
+   * Update index settings
+   */
+  async updateSettings(indexName: string, settings: IndexSettings): Promise<void> {
+    await this.engine.updateSettings(indexName, settings);
+
+    logger.info({ indexName, settings }, 'Index settings updated');
+  }
+
+  /**
+   * Get index statistics
+   */
+  async getStats(indexName: string): Promise<IndexStats> {
+    return await this.engine.getStats(indexName);
+  }
+
+  /**
+   * Autocomplete suggestions
+   */
+  async autocomplete(indexName: string, query: string, limit = 10): Promise<AutocompleteResult> {
+    return await this.engine.autocomplete(indexName, query, limit);
+  }
+
+  /**
+   * Full-text search with facets
+   */
+  async searchWithFacets<T = SearchDocument>(
+    indexName: string,
+    query: string,
+    options?: {
+      filters?: SearchQuery['filters'];
+      facets?: string[];
+      limit?: number;
+    }
+  ): Promise<SearchResult<T>> {
+    return await this.search<T>(indexName, {
+      query,
+      filters: options?.filters,
+      facets: options?.facets,
+      limit: options?.limit || 20,
+    });
+  }
+
+  /**
+   * Search similar documents
+   */
+  async searchSimilar<T = SearchDocument>(
+    indexName: string,
+    documentId: string,
+    limit = 10
+  ): Promise<SearchResult<T>> {
+    // Get the document
+    const doc = await this.getDocument(indexName, documentId);
+
+    // Use its content for similarity search
+    const searchTerms = Object.values(doc)
+      .filter((v) => typeof v === 'string')
+      .join(' ')
+      .substring(0, 200);
+
+    return await this.search<T>(indexName, {
+      query: searchTerms,
+      limit,
+    });
+  }
+
+  /**
+   * Reindex documents from one index to another
+   */
+  async reindex(
+    sourceIndex: string,
+    targetIndex: string,
+    transform?: (doc: SearchDocument) => SearchDocument
+  ): Promise<BulkIndexResult> {
+    // Get all documents from source
+    const result = await this.search(sourceIndex, {
+      query: '*',
+      limit: 10000,
+    });
+
+    // Transform if needed
+    const documents = transform
+      ? result.hits.map((hit) => transform(hit.document as SearchDocument))
+      : result.hits.map((hit) => hit.document as SearchDocument);
+
+    // Index to target
+    return await this.indexDocuments(targetIndex, documents);
+  }
+}