@kiyeonjeon21/datacontext 0.2.0 → 0.3.1

package/src/api/server.ts

@@ -403,6 +403,166 @@ export function createApiServer(config: ApiServerConfig): express.Application {
     }
   });
 
+  // ============================================================
+  // Glossary (Business Terms) Endpoints
+  // ============================================================
+
+  /**
+   * List all business terms
+   * GET /api/terms?category=status&table=users
+   */
+  app.get('/api/terms', (_req: Request, res: Response) => {
+    try {
+      const category = _req.query.category as string | undefined;
+      const table = _req.query.table as string | undefined;
+
+      let terms = service.getBusinessTerms();
+
+      // Apply filters
+      if (category) {
+        terms = terms.filter(t => t.category === category);
+      }
+      if (table) {
+        terms = terms.filter(t => t.appliesTo?.tables?.includes(table));
+      }
+
+      res.json({ 
+        count: terms.length,
+        terms,
+      });
+    } catch (error) {
+      res.status(500).json({ 
+        error: error instanceof Error ? error.message : 'Failed to get terms' 
+      });
+    }
+  });
+
+  /**
+   * Search business terms
+   * GET /api/terms/search?q=활성
+   */
+  app.get('/api/terms/search', (_req: Request, res: Response) => {
+    try {
+      const query = _req.query.q as string;
+      
+      if (!query) {
+        res.status(400).json({ error: 'q (query) parameter is required' });
+        return;
+      }
+
+      const terms = service.findMatchingTerms(query);
+
+      res.json({
+        query,
+        count: terms.length,
+        terms,
+        suggestedConditions: terms
+          .filter(t => t.sqlExpression)
+          .map(t => t.sqlExpression),
+      });
+    } catch (error) {
+      res.status(500).json({ 
+        error: error instanceof Error ? error.message : 'Failed to search terms' 
+      });
+    }
+  });
+
+  /**
+   * Add a business term manually
+   * POST /api/terms
+   * Body: { term, definition, sql?, synonyms?, tables?, category? }
+   */
+  app.post('/api/terms', async (req: Request, res: Response) => {
+    try {
+      const { term, definition, sql, synonyms, tables, category } = req.body;
+      
+      if (!term || !definition) {
+        res.status(400).json({ error: 'term and definition are required' });
+        return;
+      }
+
+      const added = await service.addBusinessTerm(term, definition, {
+        sqlExpression: sql,
+        synonyms,
+        appliesTo: tables ? { tables } : undefined,
+        category,
+      });
+
+      res.json({ success: true, term: added });
+    } catch (error) {
+      res.status(500).json({ 
+        error: error instanceof Error ? error.message : 'Failed to add term' 
+      });
+    }
+  });
+
+  /**
+   * Generate glossary from raw terms using AI
+   * POST /api/terms/generate
+   * Body: { terms: string }
+   */
+  app.post('/api/terms/generate', async (req: Request, res: Response) => {
+    try {
+      const { terms } = req.body;
+      
+      if (!terms) {
+        res.status(400).json({ error: 'terms is required' });
+        return;
+      }
+
+      const generated = await service.generateGlossary(terms);
+
+      res.json({
+        success: true,
+        generated: generated.length,
+        terms: generated,
+      });
+    } catch (error) {
+      res.status(500).json({ 
+        error: error instanceof Error ? error.message : 'Failed to generate glossary' 
+      });
+    }
+  });
+
+  /**
+   * Delete a business term
+   * DELETE /api/terms/:id
+   */
+  app.delete('/api/terms/:id', async (req: Request, res: Response) => {
+    try {
+      const { id } = req.params;
+      await service.deleteBusinessTerm(id);
+      res.json({ success: true, deleted: id });
+    } catch (error) {
+      res.status(500).json({ 
+        error: error instanceof Error ? error.message : 'Failed to delete term' 
+      });
+    }
+  });
+
+  /**
+   * Enhance a query with glossary terms
+   * POST /api/terms/enhance
+   * Body: { query: string }
+   */
+  app.post('/api/terms/enhance', async (req: Request, res: Response) => {
+    try {
+      const { query } = req.body;
+      
+      if (!query) {
+        res.status(400).json({ error: 'query is required' });
+        return;
+      }
+
+      const result = await service.enhanceQuery(query);
+      res.json(result);
+    } catch (error) {
+      res.status(500).json({ 
+        error: error instanceof Error ? error.message : 'Failed to enhance query' 
+      });
+    }
+  });
+
   // ============================================================
   // Error Handler
   // ============================================================

package/src/api/start-server.ts

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+/**
+ * Start DataContext REST API Server
+ * 
+ * Usage:
+ *   node dist/api/start-server.js
+ *   DATABASE_URL=sqlite:./test.db npm run serve
+ */
+
+import 'dotenv/config';
+import { createPostgresAdapter } from '../adapters/postgres.js';
+import { createSQLiteAdapter } from '../adapters/sqlite.js';
+import { createDataContextService } from '../core/context-service.js';
+import { KnowledgeStore } from '../knowledge/store.js';
+import { startApiServer } from './server.js';
+
+async function main() {
+  const port = parseInt(process.env.PORT || '3000', 10);
+  const dbUrl = process.env.DATABASE_URL || 'sqlite:./datacontext.db';
+  
+  console.log('[datacontext-api] Starting server...');
+  console.log(`[datacontext-api] Port: ${port}`);
+  console.log(`[datacontext-api] Database: ${dbUrl.split('?')[0]}`);
+
+  // Create appropriate adapter based on URL
+  let adapter;
+  if (dbUrl.startsWith('postgres://') || dbUrl.startsWith('postgresql://')) {
+    adapter = createPostgresAdapter(dbUrl);
+  } else if (dbUrl.startsWith('sqlite:')) {
+    const dbPath = dbUrl.replace('sqlite:', '');
+    adapter = createSQLiteAdapter(dbPath);
+  } else {
+    console.error('[datacontext-api] Unsupported database URL. Use postgres:// or sqlite:');
+    process.exit(1);
+  }
+
+  // Create knowledge store
+  const databaseId = dbUrl.split('/').pop()?.split('?')[0] || 'default';
+  const knowledge = new KnowledgeStore(databaseId);
+
+  // Create service
+  const service = createDataContextService({
+    adapter,
+    knowledge,
+    safety: {
+      readOnly: true,
+      timeoutMs: 30000,
+      maxRows: 1000,
+    },
+  });
+
+  // Initialize service
+  await service.initialize();
+  console.log('[datacontext-api] ✓ Service initialized');
+
+  try {
+    await startApiServer({
+      service,
+      port,
+      cors: true,
+    });
+    
+    console.log('[datacontext-api] ✓ Server started successfully');
+    console.log('[datacontext-api] ✓ API: http://localhost:' + port + '/api');
+    console.log('[datacontext-api] ✓ Health: http://localhost:' + port + '/health');
+    console.log('');
+    console.log('[datacontext-api] Press Ctrl+C to stop');
+  } catch (error) {
+    console.error('[datacontext-api] Failed to start server:', error);
+    process.exit(1);
+  }
+}
+
+main().catch((error) => {
+  console.error('[datacontext-api] Fatal error:', error);
+  process.exit(1);
+});
+