@libredb/studio 0.9.7

package/src/lib/db/utils/query-limiter.ts

@@ -0,0 +1,239 @@
+/**
+ * Query Limiter Utility
+ * SELECT sorgularına otomatik LIMIT ekleyerek büyük result set'lerin
+ * sistemi kilitlemesini önler.
+ */
+
+// ============================================================================
+// Constants
+// ============================================================================
+
+export const DEFAULT_QUERY_LIMIT = 500;
+export const MAX_UNLIMITED_ROWS = 100000;
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface QueryLimitOptions {
+  defaultLimit: number;
+  maxUnlimited: number;
+  forceLimit: boolean;
+}
+
+export interface ParsedQueryInfo {
+  type: 'SELECT' | 'INSERT' | 'UPDATE' | 'DELETE' | 'DDL' | 'OTHER';
+  hasLimit: boolean;
+  existingLimit?: number;
+  hasOffset: boolean;
+  existingOffset?: number;
+  isUnion: boolean;
+  hasCTE: boolean;
+  hasSubquery: boolean;
+}
+
+export interface LimitedQueryResult {
+  sql: string;
+  wasLimited: boolean;
+  originalLimit?: number;
+  appliedLimit: number;
+  appliedOffset: number;
+}
+
+// ============================================================================
+// Query Analysis
+// ============================================================================
+
+/**
+ * SQL sorgusunu analiz eder ve türünü, LIMIT/OFFSET durumunu belirler.
+ */
+/** Strip trailing semicolons and whitespace without regex to avoid ReDoS */
+function stripTrailingSemicolon(s: string): string {
+  let end = s.length;
+  while (end > 0 && (s[end - 1] === ' ' || s[end - 1] === '\t' || s[end - 1] === '\n' || s[end - 1] === '\r')) end--;
+  while (end > 0 && s[end - 1] === ';') end--;
+  while (end > 0 && (s[end - 1] === ' ' || s[end - 1] === '\t' || s[end - 1] === '\n' || s[end - 1] === '\r')) end--;
+  return s.slice(0, end);
+}
+
+export function analyzeQuery(sql: string): ParsedQueryInfo {
+  // Strip trailing whitespace and semicolons upfront to avoid ReDoS-prone patterns
+  const trimmed = stripTrailingSemicolon(sql.trim());
+  const normalized = trimmed.replace(/\s+/g, ' ').toUpperCase();
+
+  // Query type detection
+  let type: ParsedQueryInfo['type'] = 'OTHER';
+  if (/^\s*SELECT\b/i.test(trimmed)) type = 'SELECT';
+  else if (/^\s*INSERT\b/i.test(trimmed)) type = 'INSERT';
+  else if (/^\s*UPDATE\b/i.test(trimmed)) type = 'UPDATE';
+  else if (/^\s*DELETE\b/i.test(trimmed)) type = 'DELETE';
+  else if (/^\s*(CREATE|ALTER|DROP|TRUNCATE)\b/i.test(trimmed)) type = 'DDL';
+  // CTE (WITH clause) that leads to SELECT
+  else if (/^\s*WITH\b/i.test(trimmed) && /\bSELECT\b/i.test(trimmed)) {
+    type = 'SELECT';
+  }
+
+  // LIMIT/OFFSET detection - en dıştaki sorgunun LIMIT'ini bul
+  // Regex: Sorgunun sonundaki LIMIT [sayı] [OFFSET sayı] pattern'i
+  const limitMatch = trimmed.match(
+    /\bLIMIT\s+(\d+)(?:\s*,\s*(\d+)|\s+OFFSET\s+(\d+))?\s*$/i
+  );
+
+  let hasLimit = false;
+  let existingLimit: number | undefined;
+  let existingOffset: number | undefined;
+
+  if (limitMatch) {
+    hasLimit = true;
+    // LIMIT x, y format (MySQL style) veya LIMIT x OFFSET y
+    if (limitMatch[2] !== undefined) {
+      // LIMIT offset, count (MySQL style)
+      existingOffset = parseInt(limitMatch[1]);
+      existingLimit = parseInt(limitMatch[2]);
+    } else {
+      existingLimit = parseInt(limitMatch[1]);
+      existingOffset = limitMatch[3] ? parseInt(limitMatch[3]) : undefined;
+    }
+  }
+
+  // Oracle/MSSQL: FETCH FIRST N ROWS ONLY / FETCH NEXT N ROWS ONLY
+  if (!hasLimit) {
+    const fetchMatch = trimmed.match(/\bFETCH\s+(?:FIRST|NEXT)\s+(\d+)\s+ROWS?\s+ONLY\s*$/i);
+    if (fetchMatch) {
+      hasLimit = true;
+      existingLimit = parseInt(fetchMatch[1]);
+    }
+  }
+
+  // MSSQL: SELECT TOP N
+  if (!hasLimit) {
+    const topMatch = trimmed.match(/^\s*SELECT\s+TOP\s+(\d+)\b/i);
+    if (topMatch) {
+      hasLimit = true;
+      existingLimit = parseInt(topMatch[1]);
+    }
+  }
+
+  // Oracle legacy: ROWNUM in WHERE clause
+  if (!hasLimit && /\bROWNUM\s*<=?\s*\d+/i.test(normalized)) {
+    hasLimit = true;
+  }
+
+  // OFFSET without LIMIT (rare but possible in PostgreSQL)
+  const offsetOnlyMatch = !hasLimit && trimmed.match(/\bOFFSET\s+(\d+)\s*$/i);
+  const hasOffset = hasLimit ? existingOffset !== undefined : !!offsetOnlyMatch;
+
+  if (offsetOnlyMatch && !hasLimit) {
+    existingOffset = parseInt(offsetOnlyMatch[1]);
+  }
+
+  // UNION detection
+  const isUnion = /\bUNION\b/i.test(normalized);
+
+  // CTE detection (WITH clause)
+  const hasCTE = /^\s*WITH\b/i.test(trimmed);
+
+  // Subquery detection (nested SELECT - birden fazla SELECT var mı)
+  const selectCount = (normalized.match(/\bSELECT\b/g) || []).length;
+  const hasSubquery = selectCount > 1;
+
+  return {
+    type,
+    hasLimit,
+    existingLimit,
+    hasOffset,
+    existingOffset,
+    isUnion,
+    hasCTE,
+    hasSubquery,
+  };
+}
+
+// ============================================================================
+// Query Limiting
+// ============================================================================
+
+/**
+ * SELECT sorgusuna LIMIT ekler veya mevcut LIMIT'i günceller.
+ */
+export function applyQueryLimit(
+  sql: string,
+  limit: number,
+  offset: number = 0,
+  options: Partial<QueryLimitOptions> = {}
+): LimitedQueryResult {
+  const { forceLimit = false } = options;
+  const info = analyzeQuery(sql);
+
+  // SELECT değilse, limit ekleme
+  if (info.type !== 'SELECT') {
+    return {
+      sql,
+      wasLimited: false,
+      appliedLimit: 0,
+      appliedOffset: 0,
+    };
+  }
+
+  // Mevcut LIMIT varsa ve forceLimit false ise, mevcut limiti koru
+  if (info.hasLimit && !forceLimit) {
+    return {
+      sql,
+      wasLimited: false,
+      originalLimit: info.existingLimit,
+      appliedLimit: info.existingLimit || 0,
+      appliedOffset: info.existingOffset || 0,
+    };
+  }
+
+  // Check for trailing semicolon before stripping (string-based to avoid ReDoS)
+  const trimmedInput = sql.trim();
+  let modifiedSql = stripTrailingSemicolon(trimmedInput);
+  const hasSemicolon = modifiedSql.length < trimmedInput.length && trimmedInput.includes(';');
+
+  // Mevcut LIMIT/OFFSET'i kaldır (eğer forceLimit true ise)
+  if (info.hasLimit && forceLimit) {
+    // MySQL style: LIMIT offset, count
+    modifiedSql = modifiedSql
+      .replace(/\bLIMIT\s+\d+\s*,\s*\d+\s*$/i, '')
+      .trim();
+    // Standard style: LIMIT count OFFSET offset
+    modifiedSql = modifiedSql
+      .replace(/\bLIMIT\s+\d+(?:\s+OFFSET\s+\d+)?\s*$/i, '')
+      .trim();
+  }
+
+  // LIMIT OFFSET clause'u ekle
+  const limitClause =
+    offset > 0 ? `LIMIT ${limit} OFFSET ${offset}` : `LIMIT ${limit}`;
+
+  modifiedSql = `${modifiedSql} ${limitClause}`;
+
+  if (hasSemicolon) {
+    modifiedSql += ';';
+  }
+
+  return {
+    sql: modifiedSql,
+    wasLimited: true,
+    originalLimit: info.existingLimit,
+    appliedLimit: limit,
+    appliedOffset: offset,
+  };
+}
+
+/**
+ * Sorgunun LIMIT'li olup olmadığını hızlıca kontrol eder.
+ */
+export function hasQueryLimit(sql: string): boolean {
+  const info = analyzeQuery(sql);
+  return info.hasLimit;
+}
+
+/**
+ * Sorgunun SELECT türünde olup olmadığını kontrol eder.
+ */
+export function isSelectQuery(sql: string): boolean {
+  const info = analyzeQuery(sql);
+  return info.type === 'SELECT';
+}

package/src/lib/db-ui-config.ts

@@ -0,0 +1,86 @@
+import { type LucideIcon } from 'lucide-react';
+import { PostgreSQLIcon, MySQLIcon, SQLiteIcon, MongoDBIcon, RedisIcon, OracleIcon, MSSQLIcon } from '@/components/icons/db-icons';
+import type { DatabaseType } from '@/lib/types';
+
+// DB brand icons share the same interface as LucideIcon (className + SVG props)
+type DBIcon = LucideIcon | React.FC<React.SVGAttributes<SVGSVGElement> & { className?: string }>;
+
+export interface DatabaseUIConfig {
+  icon: DBIcon;
+  color: string;
+  label: string;
+  defaultPort: string;
+  showConnectionStringToggle: boolean;
+  connectionFields: ('host' | 'port' | 'user' | 'password' | 'database' | 'connectionString' | 'serviceName' | 'instanceName')[];
+}
+
+const DB_UI_CONFIG: Record<DatabaseType, DatabaseUIConfig> = {
+  postgres: {
+    icon: PostgreSQLIcon,
+    color: 'text-blue-400',
+    label: 'PostgreSQL',
+    defaultPort: '5432',
+    showConnectionStringToggle: false,
+    connectionFields: ['host', 'port', 'user', 'password', 'database'],
+  },
+  mysql: {
+    icon: MySQLIcon,
+    color: 'text-amber-400',
+    label: 'MySQL',
+    defaultPort: '3306',
+    showConnectionStringToggle: false,
+    connectionFields: ['host', 'port', 'user', 'password', 'database'],
+  },
+  sqlite: {
+    icon: SQLiteIcon,
+    color: 'text-cyan-400',
+    label: 'SQLite',
+    defaultPort: '',
+    showConnectionStringToggle: false,
+    connectionFields: ['database'],
+  },
+  mongodb: {
+    icon: MongoDBIcon,
+    color: 'text-emerald-400',
+    label: 'MongoDB',
+    defaultPort: '27017',
+    showConnectionStringToggle: true,
+    connectionFields: ['host', 'port', 'user', 'password', 'database', 'connectionString'],
+  },
+  redis: {
+    icon: RedisIcon,
+    color: 'text-rose-400',
+    label: 'Redis',
+    defaultPort: '6379',
+    showConnectionStringToggle: false,
+    connectionFields: ['host', 'port', 'password', 'database'],
+  },
+  oracle: {
+    icon: OracleIcon,
+    color: 'text-red-400',
+    label: 'Oracle',
+    defaultPort: '1521',
+    showConnectionStringToggle: false,
+    connectionFields: ['host', 'port', 'user', 'password', 'database', 'serviceName'],
+  },
+  mssql: {
+    icon: MSSQLIcon,
+    color: 'text-sky-400',
+    label: 'SQL Server',
+    defaultPort: '1433',
+    showConnectionStringToggle: false,
+    connectionFields: ['host', 'port', 'user', 'password', 'database', 'instanceName'],
+  },
+};
+
+export function getDBConfig(type: DatabaseType): DatabaseUIConfig {
+  return DB_UI_CONFIG[type];
+}
+
+export function getDBIcon(type: DatabaseType): DBIcon {
+  return DB_UI_CONFIG[type].icon;
+}
+
+export function getDBColor(type: DatabaseType): string {
+  return DB_UI_CONFIG[type].color;
+}

package/src/lib/editor/mongodb-completions.ts

@@ -0,0 +1,172 @@
+/**
+ * MongoDB / JSON Completion Provider for Monaco Editor
+ *
+ * Pure utility module (no React) that registers MQL operator, operation,
+ * collection, field, and snippet completions for the JSON language.
+ */
+
+import type * as Monaco from 'monaco-editor';
+import type { SchemaCompletionCache } from './sql-completions';
+
+// ---------------------------------------------------------------------------
+// Static constants
+// ---------------------------------------------------------------------------
+
+const MQL_OPERATORS = [
+  '$match', '$group', '$sort', '$project', '$lookup', '$unwind', '$limit', '$skip',
+  '$addFields', '$count', '$facet', '$bucket', '$merge', '$out', '$replaceRoot',
+  '$eq', '$ne', '$gt', '$gte', '$lt', '$lte', '$in', '$nin', '$and', '$or', '$not', '$nor',
+  '$exists', '$type', '$regex', '$text', '$where', '$all', '$elemMatch', '$size',
+  '$set', '$unset', '$inc', '$push', '$pull', '$addToSet', '$pop', '$rename',
+  '$sum', '$avg', '$min', '$max', '$first', '$last',
+];
+
+const MONGO_OPERATIONS = [
+  'find', 'findOne', 'aggregate', 'count', 'distinct',
+  'insertOne', 'insertMany', 'updateOne', 'updateMany', 'deleteOne', 'deleteMany',
+];
+
+const MONGO_SNIPPETS: { label: string; template: string; detail: string }[] = [
+  {
+    label: 'find',
+    template: JSON.stringify({ collection: '${1:collection}', operation: 'find', filter: {}, options: { limit: 50 } }, null, 2),
+    detail: 'Find documents',
+  },
+  {
+    label: 'findOne',
+    template: JSON.stringify({ collection: '${1:collection}', operation: 'findOne', filter: { _id: '${2:id}' } }, null, 2),
+    detail: 'Find single document',
+  },
+  {
+    label: 'aggregate',
+    template: JSON.stringify({ collection: '${1:collection}', operation: 'aggregate', pipeline: [{ '$match': {} }, { '$group': { _id: '${2:field}', count: { '$sum': 1 } } }] }, null, 2),
+    detail: 'Aggregation pipeline',
+  },
+  {
+    label: 'count',
+    template: JSON.stringify({ collection: '${1:collection}', operation: 'count', filter: {} }, null, 2),
+    detail: 'Count documents',
+  },
+  {
+    label: 'insertOne',
+    template: JSON.stringify({ collection: '${1:collection}', operation: 'insertOne', documents: [{ '${2:field}': '${3:value}' }] }, null, 2),
+    detail: 'Insert one document',
+  },
+  {
+    label: 'updateOne',
+    template: JSON.stringify({ collection: '${1:collection}', operation: 'updateOne', filter: { _id: '${2:id}' }, update: { '$set': { '${3:field}': '${4:value}' } } }, null, 2),
+    detail: 'Update one document',
+  },
+  {
+    label: 'deleteMany',
+    template: JSON.stringify({ collection: '${1:collection}', operation: 'deleteMany', filter: { '${2:field}': '${3:value}' } }, null, 2),
+    detail: 'Delete matching documents',
+  },
+];
+
+// ---------------------------------------------------------------------------
+// Registration function
+// ---------------------------------------------------------------------------
+
+/**
+ * Registers the MongoDB/JSON completion item provider with Monaco.
+ *
+ * @param monaco  - The Monaco namespace
+ * @param schemaCompletionCache - Pre-computed schema data for collection/field completions
+ * @returns An `IDisposable` that should be called on cleanup.
+ */
+export function registerMongoDBCompletionProvider(
+  monaco: typeof Monaco,
+  schemaCompletionCache: SchemaCompletionCache,
+): Monaco.IDisposable {
+  return monaco.languages.registerCompletionItemProvider('json', {
+    triggerCharacters: ['"', '$', ':'],
+    provideCompletionItems: (model: Monaco.editor.ITextModel, position: Monaco.Position) => {
+      const word = model.getWordUntilPosition(position);
+      const range = {
+        startLineNumber: position.lineNumber,
+        endLineNumber: position.lineNumber,
+        startColumn: word.startColumn,
+        endColumn: word.endColumn,
+      };
+
+      const line = model.getLineContent(position.lineNumber);
+      const textBefore = line.substring(0, position.column - 1);
+      const suggestions: Monaco.languages.CompletionItem[] = [];
+
+      // After "$" -- MQL operators
+      if (textBefore.includes('$') || word.word.startsWith('$')) {
+        MQL_OPERATORS.forEach(op => {
+          suggestions.push({
+            label: op,
+            kind: monaco.languages.CompletionItemKind.Keyword,
+            insertText: op,
+            range,
+            detail: 'MQL Operator',
+            sortText: '0' + op,
+          });
+        });
+      }
+
+      // After "operation": " -- operation names
+      if (/"operation"\s*:\s*"[^"]*$/.test(textBefore)) {
+        MONGO_OPERATIONS.forEach(op => {
+          suggestions.push({
+            label: op,
+            kind: monaco.languages.CompletionItemKind.Enum,
+            insertText: op,
+            range,
+            detail: 'MongoDB Operation',
+            sortText: '0' + op,
+          });
+        });
+      }
+
+      // After "collection": " -- collection names from schema
+      if (/"collection"\s*:\s*"[^"]*$/.test(textBefore)) {
+        schemaCompletionCache.tableItems.forEach(table => {
+          suggestions.push({
+            label: table.label,
+            kind: monaco.languages.CompletionItemKind.Class,
+            insertText: table.label,
+            range,
+            detail: `Collection (${table.rowCount} docs)`,
+            sortText: '0' + table.label,
+          });
+        });
+      }
+
+      // Field names inside filter/sort/projection
+      if (/"[^"]*$/.test(textBefore) && !/"(collection|operation)"\s*:\s*"/.test(textBefore)) {
+        schemaCompletionCache.allColumns.forEach((col, colName) => {
+          suggestions.push({
+            label: colName,
+            kind: monaco.languages.CompletionItemKind.Field,
+            insertText: colName,
+            range,
+            detail: `Field (${col.type})`,
+            sortText: '2' + colName,
+          });
+        });
+      }
+
+      // Full template snippets -- when editor is mostly empty or at line start
+      const fullText = model.getValue().trim();
+      if (fullText.length < 5 || /^\s*$/.test(textBefore)) {
+        MONGO_SNIPPETS.forEach(snippet => {
+          suggestions.push({
+            label: snippet.label,
+            kind: monaco.languages.CompletionItemKind.Snippet,
+            insertText: snippet.template,
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range,
+            detail: snippet.detail,
+            sortText: '1' + snippet.label,
+          });
+        });
+      }
+
+      return { suggestions };
+    },
+  });
+}