@mhalder/qdrant-mcp-server 1.3.1 → 1.5.0

package/tests/code/fixtures/sample-ts/types-advanced.ts

@@ -0,0 +1,132 @@
+/**
+ * Advanced TypeScript type features
+ */
+
+// Generic constraints
+export interface Identifiable {
+  id: string | number;
+}
+
+export class Repository<T extends Identifiable> {
+  private items: Map<string | number, T> = new Map();
+
+  add(item: T): void {
+    this.items.set(item.id, item);
+  }
+
+  get(id: string | number): T | undefined {
+    return this.items.get(id);
+  }
+
+  getAll(): T[] {
+    return Array.from(this.items.values());
+  }
+
+  remove(id: string | number): boolean {
+    return this.items.delete(id);
+  }
+}
+
+// Conditional types
+export type Awaited<T> = T extends Promise<infer U> ? U : T;
+export type NonNullable<T> = T extends null | undefined ? never : T;
+export type ReturnTypeOf<T> = T extends (...args: any[]) => infer R ? R : never;
+
+// Mapped types
+export type Readonly<T> = {
+  readonly [P in keyof T]: T[P];
+};
+
+export type Partial<T> = {
+  [P in keyof T]?: T[P];
+};
+
+export type Required<T> = {
+  [P in keyof T]-?: T[P];
+};
+
+// Type guards
+export function isString(value: unknown): value is string {
+  return typeof value === "string";
+}
+
+export function isNumber(value: unknown): value is number {
+  return typeof value === "number";
+}
+
+export function isArray<T>(value: unknown): value is T[] {
+  return Array.isArray(value);
+}
+
+export function hasProperty<K extends string>(obj: unknown, key: K): obj is Record<K, unknown> {
+  return typeof obj === "object" && obj !== null && key in obj;
+}
+
+// Generic factory
+export class Factory<T> {
+  constructor(private creator: () => T) {}
+
+  create(): T {
+    return this.creator();
+  }
+
+  createMany(count: number): T[] {
+    return Array.from({ length: count }, () => this.create());
+  }
+}
+
+// Builder pattern with fluent interface
+export class QueryBuilder<T> {
+  private filters: Array<(item: T) => boolean> = [];
+  private sortFn?: (a: T, b: T) => number;
+  private limitValue?: number;
+
+  where(predicate: (item: T) => boolean): this {
+    this.filters.push(predicate);
+    return this;
+  }
+
+  orderBy(compareFn: (a: T, b: T) => number): this {
+    this.sortFn = compareFn;
+    return this;
+  }
+
+  limit(count: number): this {
+    this.limitValue = count;
+    return this;
+  }
+
+  execute(items: T[]): T[] {
+    let result = items;
+
+    // Apply filters
+    for (const filter of this.filters) {
+      result = result.filter(filter);
+    }
+
+    // Apply sorting
+    if (this.sortFn) {
+      result = result.sort(this.sortFn);
+    }
+
+    // Apply limit
+    if (this.limitValue !== undefined) {
+      result = result.slice(0, this.limitValue);
+    }
+
+    return result;
+  }
+}
+
+// Utility types
+export type DeepPartial<T> = {
+  [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+
+export type PickByType<T, ValueType> = {
+  [K in keyof T as T[K] extends ValueType ? K : never]: T[K];
+};
+
+export type OmitByType<T, ValueType> = {
+  [K in keyof T as T[K] extends ValueType ? never : K]: T[K];
+};

package/tests/code/fixtures/sample-ts/utils.ts

@@ -0,0 +1,105 @@
+/**
+ * Utility functions for string manipulation
+ */
+
+export function capitalize(str: string): string {
+  if (!str) return "";
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+export function slugify(text: string): string {
+  return text
+    .toLowerCase()
+    .replace(/[^\w\s-]/g, "")
+    .replace(/[\s_-]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+/**
+ * Validates email format
+ */
+export function isValidEmail(email: string): boolean {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(email);
+}
+
+/**
+ * Debounce function to limit execution rate
+ */
+export function debounce<T extends (...args: any[]) => any>(
+  func: T,
+  wait: number
+): (...args: Parameters<T>) => void {
+  let timeout: NodeJS.Timeout | null = null;
+
+  return function executedFunction(...args: Parameters<T>) {
+    const later = () => {
+      timeout = null;
+      func(...args);
+    };
+
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+    timeout = setTimeout(later, wait);
+  };
+}
+
+/**
+ * Deep clone an object
+ */
+export function deepClone<T>(obj: T): T {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+
+  if (obj instanceof Date) {
+    return new Date(obj.getTime()) as any;
+  }
+
+  if (Array.isArray(obj)) {
+    const clonedArr: any[] = [];
+    for (let i = 0; i < obj.length; i++) {
+      clonedArr[i] = deepClone(obj[i]);
+    }
+    return clonedArr as any;
+  }
+
+  if (obj instanceof Object) {
+    const clonedObj: any = {};
+    for (const key in obj) {
+      if (Object.hasOwn(obj, key)) {
+        clonedObj[key] = deepClone(obj[key]);
+      }
+    }
+    return clonedObj;
+  }
+
+  return obj;
+}
+
+/**
+ * Retry a function with exponential backoff
+ */
+export async function retry<T>(
+  fn: () => Promise<T>,
+  maxRetries: number = 3,
+  delay: number = 1000
+): Promise<T> {
+  let lastError: Error;
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error as Error;
+
+      if (attempt < maxRetries) {
+        const backoffDelay = delay * 2 ** attempt;
+        await new Promise((resolve) => setTimeout(resolve, backoffDelay));
+      }
+    }
+  }
+
+  throw lastError!;
+}

package/tests/code/fixtures/sample-ts/validator.ts

@@ -0,0 +1,169 @@
+/**
+ * Complex validation logic with high cyclomatic complexity
+ */
+
+export interface ValidationResult {
+  valid: boolean;
+  errors: string[];
+}
+
+export class Validator {
+  /**
+   * Validates user input with multiple conditions
+   */
+  validateUserInput(input: any): ValidationResult {
+    const errors: string[] = [];
+
+    if (!input) {
+      errors.push("Input is required");
+      return { valid: false, errors };
+    }
+
+    if (typeof input.email === "string") {
+      if (input.email.length < 5) {
+        errors.push("Email too short");
+      } else if (input.email.length > 100) {
+        errors.push("Email too long");
+      } else if (!input.email.includes("@")) {
+        errors.push("Invalid email format");
+      } else if (input.email.startsWith("@") || input.email.endsWith("@")) {
+        errors.push("Email cannot start or end with @");
+      }
+    } else {
+      errors.push("Email must be a string");
+    }
+
+    if (input.age !== undefined) {
+      if (typeof input.age !== "number") {
+        errors.push("Age must be a number");
+      } else if (input.age < 0) {
+        errors.push("Age cannot be negative");
+      } else if (input.age > 150) {
+        errors.push("Age seems unrealistic");
+      } else if (input.age < 13) {
+        errors.push("Must be 13 or older");
+      }
+    }
+
+    if (input.password) {
+      const pwd = input.password;
+      if (pwd.length < 8) {
+        errors.push("Password too short");
+      } else if (pwd.length > 128) {
+        errors.push("Password too long");
+      }
+
+      let hasUpper = false;
+      let hasLower = false;
+      let hasDigit = false;
+      let hasSpecial = false;
+
+      for (const char of pwd) {
+        if (char >= "A" && char <= "Z") {
+          hasUpper = true;
+        } else if (char >= "a" && char <= "z") {
+          hasLower = true;
+        } else if (char >= "0" && char <= "9") {
+          hasDigit = true;
+        } else if ("!@#$%^&*()_+-=[]{}|;:,.<>?".includes(char)) {
+          hasSpecial = true;
+        }
+      }
+
+      if (!hasUpper) {
+        errors.push("Password needs uppercase letter");
+      }
+      if (!hasLower) {
+        errors.push("Password needs lowercase letter");
+      }
+      if (!hasDigit) {
+        errors.push("Password needs digit");
+      }
+      if (!hasSpecial) {
+        errors.push("Password needs special character");
+      }
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+    };
+  }
+
+  /**
+   * Process data with multiple switch cases and conditions
+   */
+  processData(data: any, type: string): any {
+    switch (type) {
+      case "string":
+        return String(data);
+      case "number":
+        return Number(data);
+      case "boolean":
+        return Boolean(data);
+      case "array":
+        if (Array.isArray(data)) {
+          return data;
+        } else if (data === null || data === undefined) {
+          return [];
+        } else {
+          return [data];
+        }
+      case "object":
+        if (typeof data === "object" && data !== null) {
+          return data;
+        } else {
+          return { value: data };
+        }
+      case "json":
+        try {
+          return JSON.parse(data);
+        } catch (_e) {
+          return null;
+        }
+      default:
+        return data;
+    }
+  }
+
+  /**
+   * Complex nested conditions
+   */
+  checkPermissions(user: any, resource: string, action: string): boolean {
+    if (!user) {
+      return false;
+    }
+
+    if (user.role === "admin") {
+      return true;
+    }
+
+    if (user.role === "moderator") {
+      if (action === "read" || action === "update") {
+        return true;
+      } else if (action === "delete" && resource !== "user") {
+        return true;
+      }
+    }
+
+    if (user.role === "user") {
+      if (action === "read") {
+        return true;
+      } else if (action === "update" && resource === "profile") {
+        return user.id === resource;
+      }
+    }
+
+    if (user.permissions && Array.isArray(user.permissions)) {
+      for (const perm of user.permissions) {
+        if (perm.resource === resource && (perm.action === action || perm.action === "*")) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+}
+
+export default Validator;