@nicia-ai/typegraph 0.1.0

package/dist/profiler/index.cjs

@@ -0,0 +1,793 @@
+'use strict';
+
+var chunkP5CNM325_cjs = require('../chunk-P5CNM325.cjs');
+require('../chunk-JEQ2X3Z6.cjs');
+
+// src/profiler/ast-extractor.ts
+function extractPropertyAccesses(ast) {
+  const accesses = [];
+  for (const predicate of ast.predicates) {
+    const extracted = extractFromNodePredicate(predicate, ast);
+    accesses.push(...extracted);
+  }
+  if (ast.orderBy) {
+    for (const order of ast.orderBy) {
+      const extracted = extractFromOrderSpec(order, ast);
+      if (extracted) {
+        accesses.push(extracted);
+      }
+    }
+  }
+  for (const field of ast.projection.fields) {
+    const extracted = extractFromProjectedField(field, ast);
+    if (extracted) {
+      accesses.push(extracted);
+    }
+  }
+  if (ast.groupBy) {
+    for (const field of ast.groupBy.fields) {
+      const extracted = extractFromFieldRef(field, "groupBy", ast);
+      if (extracted) {
+        accesses.push(extracted);
+      }
+    }
+  }
+  if (ast.having) {
+    const havingAccesses = extractFromExpression(ast.having, void 0, ast);
+    accesses.push(...havingAccesses);
+  }
+  if (ast.selectiveFields) {
+    for (const field of ast.selectiveFields) {
+      const extracted = extractFromSelectiveField(field, ast);
+      if (extracted) {
+        accesses.push(extracted);
+      }
+    }
+  }
+  return accesses;
+}
+function extractFromNodePredicate(predicate, ast) {
+  return extractFromExpression(
+    predicate.expression,
+    predicate.targetAlias,
+    ast
+  );
+}
+function extractFromExpression(expr, alias, ast) {
+  const accesses = [];
+  switch (expr.__type) {
+    case "comparison": {
+      const extracted = extractFromFieldRef(expr.left, "filter", ast);
+      if (extracted) {
+        accesses.push({ ...extracted, predicateType: expr.op });
+      }
+      break;
+    }
+    case "string_op": {
+      const extracted = extractFromFieldRef(expr.field, "filter", ast);
+      if (extracted) {
+        accesses.push({ ...extracted, predicateType: expr.op });
+      }
+      break;
+    }
+    case "null_check": {
+      const extracted = extractFromFieldRef(expr.field, "filter", ast);
+      if (extracted) {
+        accesses.push({ ...extracted, predicateType: expr.op });
+      }
+      break;
+    }
+    case "between": {
+      const extracted = extractFromFieldRef(expr.field, "filter", ast);
+      if (extracted) {
+        accesses.push({ ...extracted, predicateType: "between" });
+      }
+      break;
+    }
+    case "array_op": {
+      const extracted = extractFromFieldRef(expr.field, "filter", ast);
+      if (extracted) {
+        accesses.push({ ...extracted, predicateType: expr.op });
+      }
+      break;
+    }
+    case "object_op": {
+      const extracted = extractFromFieldRef(expr.field, "filter", ast);
+      if (extracted) {
+        accesses.push({ ...extracted, predicateType: expr.op });
+      }
+      break;
+    }
+    case "and":
+    case "or": {
+      for (const sub of expr.predicates) {
+        accesses.push(...extractFromExpression(sub, alias, ast));
+      }
+      break;
+    }
+    case "not": {
+      accesses.push(...extractFromExpression(expr.predicate, alias, ast));
+      break;
+    }
+    case "aggregate_comparison": {
+      const extracted = extractFromFieldRef(
+        expr.aggregate.field,
+        "filter",
+        ast
+      );
+      if (extracted) {
+        accesses.push({
+          ...extracted,
+          predicateType: `${expr.aggregate.function}_${expr.op}`
+        });
+      }
+      break;
+    }
+    case "exists": {
+      const subAccesses = extractPropertyAccesses(expr.subquery);
+      accesses.push(...subAccesses);
+      break;
+    }
+    case "in_subquery": {
+      const extracted = extractFromFieldRef(expr.field, "filter", ast);
+      if (extracted) {
+        accesses.push({ ...extracted, predicateType: "in_subquery" });
+      }
+      const subAccesses = extractPropertyAccesses(expr.subquery);
+      accesses.push(...subAccesses);
+      break;
+    }
+    case "vector_similarity": {
+      const extracted = extractFromFieldRef(expr.field, "filter", ast);
+      if (extracted) {
+        accesses.push({ ...extracted, predicateType: "vector_similarity" });
+      }
+      break;
+    }
+  }
+  return accesses;
+}
+function extractFromOrderSpec(order, ast) {
+  return extractFromFieldRef(order.field, "sort", ast);
+}
+function extractFromProjectedField(field, ast) {
+  if (field.source.__type === "aggregate") {
+    return extractFromFieldRef(field.source.field, "select", ast);
+  }
+  return extractFromFieldRef(field.source, "select", ast);
+}
+function extractFromSelectiveField(field, ast) {
+  if (field.isSystemField) {
+    return void 0;
+  }
+  const resolved = resolveAliasToKinds(field.alias, ast);
+  if (!resolved) {
+    return void 0;
+  }
+  return {
+    entityType: resolved.entityType,
+    kindNames: resolved.kindNames,
+    target: {
+      __type: "prop",
+      pointer: chunkP5CNM325_cjs.jsonPointer(field.field.split("."))
+    },
+    context: "select"
+  };
+}
+function extractFromFieldRef(ref, context, ast) {
+  const resolved = resolveAliasToKinds(ref.alias, ast);
+  if (!resolved) {
+    return void 0;
+  }
+  const target = extractTargetFromFieldRef(ref);
+  if (!target) {
+    return void 0;
+  }
+  return {
+    entityType: resolved.entityType,
+    kindNames: resolved.kindNames,
+    target,
+    context
+  };
+}
+function resolveAliasToKinds(alias, ast) {
+  if (ast.start.alias === alias) {
+    return { entityType: "node", kindNames: ast.start.kinds };
+  }
+  for (const traversal of ast.traversals) {
+    if (traversal.nodeAlias === alias) {
+      return { entityType: "node", kindNames: traversal.nodeKinds };
+    }
+    if (traversal.edgeAlias === alias) {
+      return { entityType: "edge", kindNames: traversal.edgeKinds };
+    }
+  }
+  return void 0;
+}
+function extractTargetFromFieldRef(ref) {
+  if (ref.jsonPointer) {
+    return { __type: "prop", pointer: ref.jsonPointer };
+  }
+  if (ref.path.length > 1 && ref.path[0] === "props") {
+    return { __type: "prop", pointer: chunkP5CNM325_cjs.jsonPointer(ref.path.slice(1)) };
+  }
+  if (ref.path.length === 1) {
+    return { __type: "system", field: ref.path[0] };
+  }
+  return void 0;
+}
+
+// src/profiler/collector.ts
+function pathToKey(path) {
+  const targetKey = path.target.__type === "prop" ? path.target.pointer : `$${path.target.field}`;
+  return `${path.entityType}:${path.kind}:${targetKey}`;
+}
+function keyToPath(key) {
+  const firstColonIndex = key.indexOf(":");
+  const secondColonIndex = firstColonIndex === -1 ? -1 : key.indexOf(":", firstColonIndex + 1);
+  if (firstColonIndex === -1 || secondColonIndex === -1) {
+    throw new Error(
+      `Invalid profile key: "${key}". Expected format "{entityType}:{kind}:{target}".`
+    );
+  }
+  const entityTypePart = key.slice(0, firstColonIndex);
+  const kind = key.slice(firstColonIndex + 1, secondColonIndex);
+  if (kind === "") {
+    throw new Error(`Invalid profile key: "${key}". Kind must not be empty.`);
+  }
+  const targetPart = key.slice(secondColonIndex + 1);
+  const entityType = parseEntityType(entityTypePart);
+  if (targetPart.startsWith("$")) {
+    const systemField = targetPart.slice(1);
+    if (systemField === "") {
+      throw new Error(
+        `Invalid profile key: "${key}". System field must not be empty.`
+      );
+    }
+    return {
+      entityType,
+      kind,
+      target: { __type: "system", field: systemField }
+    };
+  }
+  const pointer = chunkP5CNM325_cjs.normalizeJsonPointer(
+    targetPart
+  );
+  return {
+    entityType,
+    kind,
+    target: { __type: "prop", pointer }
+  };
+}
+function parseEntityType(value) {
+  if (value === "node" || value === "edge") {
+    return value;
+  }
+  throw new Error(
+    `Invalid entity type in profile key: "${value}". Expected "node" or "edge".`
+  );
+}
+var ProfileCollector = class {
+  #patterns = /* @__PURE__ */ new Map();
+  #startedAt = /* @__PURE__ */ new Date();
+  #queryCount = 0;
+  /**
+   * Records a property access.
+   *
+   * @param path - The property path that was accessed
+   * @param context - How the property was used (filter, sort, select, groupBy)
+   * @param predicateType - Optional predicate type (eq, contains, gt, etc.)
+   */
+  record(path, context, predicateType) {
+    const key = pathToKey(path);
+    const existing = this.#patterns.get(key);
+    const nowMs = Date.now();
+    if (existing) {
+      existing.count++;
+      existing.contexts.add(context);
+      if (predicateType) {
+        existing.predicateTypes.add(predicateType);
+      }
+      existing.lastSeenMs = nowMs;
+    } else {
+      this.#patterns.set(key, {
+        count: 1,
+        contexts: /* @__PURE__ */ new Set([context]),
+        predicateTypes: predicateType ? /* @__PURE__ */ new Set([predicateType]) : /* @__PURE__ */ new Set(),
+        firstSeenMs: nowMs,
+        lastSeenMs: nowMs
+      });
+    }
+  }
+  /**
+   * Increments the query count.
+   * Call this once per query execution.
+   */
+  recordQuery() {
+    this.#queryCount++;
+  }
+  /**
+   * Gets all patterns as an immutable map.
+   *
+   * Returns a new Map with immutable stats objects.
+   */
+  getPatterns() {
+    const result = /* @__PURE__ */ new Map();
+    for (const [key, stats] of this.#patterns) {
+      result.set(key, {
+        count: stats.count,
+        contexts: new Set(stats.contexts),
+        predicateTypes: new Set(stats.predicateTypes),
+        firstSeen: new Date(stats.firstSeenMs),
+        lastSeen: new Date(stats.lastSeenMs)
+      });
+    }
+    return result;
+  }
+  /**
+   * Gets summary statistics.
+   */
+  getSummary() {
+    return {
+      totalQueries: this.#queryCount,
+      uniquePatterns: this.#patterns.size,
+      startedAt: this.#startedAt,
+      durationMs: Date.now() - this.#startedAt.getTime()
+    };
+  }
+  /**
+   * Resets all collected data.
+   *
+   * Note: This does not reset the startedAt timestamp.
+   * Create a new ProfileCollector for a fresh session.
+   */
+  reset() {
+    this.#patterns.clear();
+    this.#queryCount = 0;
+  }
+};
+
+// src/profiler/constants.ts
+var DEFAULT_MIN_FREQUENCY_FOR_RECOMMENDATION = 3;
+var DEFAULT_HIGH_FREQUENCY_THRESHOLD = 10;
+var DEFAULT_MEDIUM_FREQUENCY_THRESHOLD = 5;
+
+// src/profiler/recommendations.ts
+function generateRecommendations(patterns, declaredIndexes, options = {}) {
+  const recommendations = [];
+  const indexedPaths = buildIndexedPathsSet(declaredIndexes);
+  const config = normalizeRecommendationsOptions(options);
+  for (const [key, stats] of patterns) {
+    const hasFilterOrSort = stats.contexts.has("filter") || stats.contexts.has("sort");
+    if (!hasFilterOrSort) {
+      continue;
+    }
+    if (stats.count < config.minFrequencyForRecommendation) {
+      continue;
+    }
+    const path = keyToPath(key);
+    if (isSystemField(path)) {
+      continue;
+    }
+    if (isIndexed(path, indexedPaths)) {
+      continue;
+    }
+    recommendations.push({
+      entityType: path.entityType,
+      kind: path.kind,
+      fields: path.target.__type === "prop" ? [path.target.pointer] : [],
+      reason: buildReasonString(stats),
+      frequency: stats.count,
+      priority: getPriority(stats.count, config)
+    });
+  }
+  return recommendations.toSorted((a, b) => {
+    const priorityOrder = {
+      high: 0,
+      medium: 1,
+      low: 2
+    };
+    const priorityDiff = priorityOrder[a.priority] - priorityOrder[b.priority];
+    if (priorityDiff !== 0) return priorityDiff;
+    return b.frequency - a.frequency;
+  });
+}
+function getUnindexedFilters(patterns, declaredIndexes) {
+  const indexedPaths = buildIndexedPathsSet(declaredIndexes);
+  const unindexed = [];
+  for (const [key, stats] of patterns) {
+    if (!stats.contexts.has("filter")) {
+      continue;
+    }
+    const path = keyToPath(key);
+    if (isSystemField(path)) {
+      continue;
+    }
+    if (!isIndexed(path, indexedPaths)) {
+      unindexed.push(path);
+    }
+  }
+  return unindexed;
+}
+function buildIndexedPathsSet(indexes) {
+  const set = /* @__PURE__ */ new Set();
+  for (const index of indexes) {
+    const firstField = index.fields[0];
+    if (!firstField) continue;
+    set.add(
+      pathToKey({
+        entityType: index.entityType,
+        kind: index.kind,
+        target: { __type: "prop", pointer: firstField }
+      })
+    );
+  }
+  return set;
+}
+function isIndexed(path, indexedPaths) {
+  return indexedPaths.has(pathToKey(path));
+}
+function isSystemField(path) {
+  return path.target.__type === "system";
+}
+function buildReasonString(stats) {
+  const contexts = [...stats.contexts].join(", ");
+  const predicates = [...stats.predicateTypes];
+  let reason = `Used in ${contexts}`;
+  if (predicates.length > 0) {
+    reason += ` with ${predicates.join(", ")}`;
+  }
+  reason += ` (${stats.count} ${stats.count === 1 ? "time" : "times"})`;
+  return reason;
+}
+function normalizeRecommendationsOptions(options) {
+  if (typeof options === "number") {
+    return {
+      minFrequencyForRecommendation: options,
+      mediumFrequencyThreshold: DEFAULT_MEDIUM_FREQUENCY_THRESHOLD,
+      highFrequencyThreshold: DEFAULT_HIGH_FREQUENCY_THRESHOLD
+    };
+  }
+  return {
+    minFrequencyForRecommendation: options.minFrequencyForRecommendation ?? DEFAULT_MIN_FREQUENCY_FOR_RECOMMENDATION,
+    mediumFrequencyThreshold: options.mediumFrequencyThreshold ?? DEFAULT_MEDIUM_FREQUENCY_THRESHOLD,
+    highFrequencyThreshold: options.highFrequencyThreshold ?? DEFAULT_HIGH_FREQUENCY_THRESHOLD
+  };
+}
+function getPriority(frequency, options) {
+  if (frequency >= options.highFrequencyThreshold) return "high";
+  if (frequency >= options.mediumFrequencyThreshold) return "medium";
+  return "low";
+}
+
+// src/profiler/query-profiler.ts
+var QueryProfiler = class {
+  #collector = new ProfileCollector();
+  #declaredIndexes;
+  #minFrequencyForRecommendation;
+  #mediumFrequencyThreshold;
+  #highFrequencyThreshold;
+  #schemaIntrospector;
+  #attached = false;
+  constructor(options) {
+    this.#declaredIndexes = options?.declaredIndexes ?? [];
+    this.#minFrequencyForRecommendation = options?.minFrequencyForRecommendation ?? DEFAULT_MIN_FREQUENCY_FOR_RECOMMENDATION;
+    this.#mediumFrequencyThreshold = options?.mediumFrequencyThreshold ?? DEFAULT_MEDIUM_FREQUENCY_THRESHOLD;
+    this.#highFrequencyThreshold = options?.highFrequencyThreshold ?? DEFAULT_HIGH_FREQUENCY_THRESHOLD;
+  }
+  /**
+   * Records a query execution from its AST.
+   *
+   * This is called automatically when attached to a store.
+   * Can also be called manually for custom integrations.
+   *
+   * @param ast - The query AST to analyze
+   */
+  recordQuery(ast) {
+    this.#collector.recordQuery();
+    const accesses = extractPropertyAccesses(ast);
+    for (const access of accesses) {
+      const paths = resolveAccessPaths(access, this.#schemaIntrospector);
+      for (const path of paths) {
+        this.#collector.record(path, access.context, access.predicateType);
+      }
+    }
+  }
+  /**
+   * Attaches the profiler to a store.
+   *
+   * Returns a wrapped store that tracks all query executions.
+   * The wrapped store behaves identically to the original.
+   *
+   * @param store - The store to attach to
+   * @returns A profiled store with the `profiler` property
+   * @throws Error if the profiler is already attached to another store
+   */
+  attachToStore(store) {
+    if (this.#attached) {
+      throw new Error(
+        "Profiler is already attached. Call detach() first or create a new profiler."
+      );
+    }
+    this.#attached = true;
+    this.#schemaIntrospector = chunkP5CNM325_cjs.createSchemaIntrospector(
+      buildNodeSchemaMap(store.graph),
+      buildEdgeSchemaMap(store.graph)
+    );
+    return createProfiledStore(store, this);
+  }
+  /**
+   * Generates a complete profile report.
+   *
+   * The report includes:
+   * - All property access patterns with frequency and context
+   * - Index recommendations sorted by priority
+   * - List of unindexed filter properties
+   * - Summary statistics
+   *
+   * @returns The profile report
+   */
+  getReport() {
+    const patterns = this.#collector.getPatterns();
+    const summary = this.#collector.getSummary();
+    return {
+      patterns,
+      recommendations: generateRecommendations(
+        patterns,
+        this.#declaredIndexes,
+        {
+          minFrequencyForRecommendation: this.#minFrequencyForRecommendation,
+          mediumFrequencyThreshold: this.#mediumFrequencyThreshold,
+          highFrequencyThreshold: this.#highFrequencyThreshold
+        }
+      ),
+      summary,
+      unindexedFilters: getUnindexedFilters(patterns, this.#declaredIndexes)
+    };
+  }
+  /**
+   * Checks if all filtered properties are covered by indexes.
+   *
+   * Throws an error if any filtered properties lack indexes.
+   * Useful for test assertions to ensure query performance.
+   *
+   * @throws Error if unindexed filter properties are found
+   *
+   * @example
+   * ```typescript
+   * // In your test file
+   * it("all filtered properties should be indexed", () => {
+   *   profiler.assertIndexCoverage();
+   * });
+   * ```
+   */
+  assertIndexCoverage() {
+    const report = this.getReport();
+    if (report.unindexedFilters.length > 0) {
+      const missing = report.unindexedFilters.map((p) => formatPropertyPath(p)).join(", ");
+      throw new Error(`Unindexed filter properties: ${missing}`);
+    }
+  }
+  /**
+   * Resets all collected data.
+   *
+   * Clears patterns and query count. Useful for starting a fresh
+   * profiling session without creating a new profiler instance.
+   */
+  reset() {
+    this.#collector.reset();
+  }
+  /**
+   * Marks the profiler as detached.
+   *
+   * Call this when you're done profiling to allow reattachment
+   * to the same or a different store.
+   */
+  detach() {
+    this.#attached = false;
+    this.#schemaIntrospector = void 0;
+  }
+  /**
+   * Whether the profiler is currently attached to a store.
+   */
+  get isAttached() {
+    return this.#attached;
+  }
+};
+function buildNodeSchemaMap(graph) {
+  const entries = Object.values(graph.nodes).map(
+    (n) => [n.type.name, { schema: n.type.schema }]
+  );
+  return new Map(entries);
+}
+function buildEdgeSchemaMap(graph) {
+  const entries = Object.values(graph.edges).map(
+    (edgeRegistration) => [
+      edgeRegistration.type.name,
+      { schema: edgeRegistration.type.schema }
+    ]
+  );
+  return new Map(entries);
+}
+function resolveAccessPaths(access, schemaIntrospector) {
+  const kinds = access.kindNames;
+  if (kinds.length === 0) {
+    warnInDevelopment(
+      `[QueryProfiler] Access pattern has empty kindNames for context "${access.context}". This may indicate a bug in alias resolution.`
+    );
+    return [];
+  }
+  if (!schemaIntrospector) {
+    return [
+      {
+        entityType: access.entityType,
+        kind: kinds[0],
+        target: access.target
+      }
+    ];
+  }
+  if (access.target.__type !== "prop") {
+    return [
+      {
+        entityType: access.entityType,
+        kind: kinds[0],
+        target: access.target
+      }
+    ];
+  }
+  const pointer = access.target.pointer;
+  const matchingKinds = kinds.filter(
+    (kindName) => hasPointerInSchema(
+      schemaIntrospector,
+      access.entityType,
+      kindName,
+      pointer
+    )
+  );
+  const kindsToUse = matchingKinds.length > 0 ? matchingKinds : [kinds[0]];
+  return kindsToUse.map((kindName) => ({
+    entityType: access.entityType,
+    kind: kindName,
+    target: access.target
+  }));
+}
+function warnInDevelopment(message, details) {
+  if (!isDevelopmentEnvironment()) {
+    return;
+  }
+  if (details !== void 0) {
+    console.warn(message, details);
+    return;
+  }
+  console.warn(message);
+}
+function isDevelopmentEnvironment() {
+  return getNodeEnv() !== "production";
+}
+function getNodeEnv() {
+  if (typeof process === "undefined") {
+    return void 0;
+  }
+  return process.env.NODE_ENV;
+}
+function hasPointerInSchema(schemaIntrospector, entityType, kindName, pointer) {
+  const segments = chunkP5CNM325_cjs.parseJsonPointer(pointer);
+  const [first, ...rest] = segments;
+  if (!first) {
+    return false;
+  }
+  const rootInfo = entityType === "node" ? schemaIntrospector.getFieldTypeInfo(kindName, first) : schemaIntrospector.getEdgeFieldTypeInfo(kindName, first);
+  if (!rootInfo) {
+    return false;
+  }
+  if (rest.length === 0) {
+    return true;
+  }
+  try {
+    const resolved = chunkP5CNM325_cjs.resolveFieldTypeInfoAtJsonPointer(
+      rootInfo,
+      chunkP5CNM325_cjs.jsonPointer(rest)
+    );
+    return resolved !== void 0;
+  } catch (error) {
+    warnInDevelopment(
+      `[QueryProfiler] Failed to resolve pointer "${pointer}" for ${entityType} kind "${kindName}".`,
+      error
+    );
+    return false;
+  }
+}
+function formatPropertyPath(path) {
+  const target = path.target.__type === "prop" ? path.target.pointer : `$${path.target.field}`;
+  return `${path.entityType}:${path.kind}:${target}`;
+}
+function createProfiledStore(store, profiler) {
+  const handler = {
+    get(target, property, _receiver) {
+      if (property === "profiler") {
+        return profiler;
+      }
+      if (property === "query") {
+        return () => {
+          const builder = target.query();
+          return wrapQueryBuilder(builder, profiler);
+        };
+      }
+      const value = Reflect.get(target, property, target);
+      if (typeof value === "function") {
+        return value.bind(target);
+      }
+      return value;
+    }
+  };
+  return new Proxy(store, handler);
+}
+function wrapQueryBuilder(builder, profiler) {
+  const handler = {
+    get(target, property, receiver) {
+      const value = Reflect.get(target, property, receiver);
+      if (typeof value !== "function") {
+        return value;
+      }
+      return (...args) => {
+        const result = value.apply(target, args);
+        if (result === null || typeof result !== "object") {
+          return result;
+        }
+        if (hasExecutableQueryShape(result)) {
+          return wrapExecutableQuery(result, profiler);
+        }
+        if (hasQueryBuilderShape(result)) {
+          return wrapQueryBuilder(result, profiler);
+        }
+        return result;
+      };
+    }
+  };
+  return new Proxy(builder, handler);
+}
+function wrapExecutableQuery(query, profiler) {
+  const handler = {
+    get(target, property, receiver) {
+      const value = Reflect.get(target, property, receiver);
+      if (typeof value !== "function") {
+        return value;
+      }
+      const fn = value;
+      return (...args) => {
+        if (property === "execute" || property === "paginate" || property === "stream") {
+          const toAst = Reflect.get(
+            target,
+            "toAst",
+            receiver
+          );
+          const ast = toAst.call(target);
+          profiler.recordQuery(ast);
+        }
+        const result = fn.apply(target, args);
+        if (result && typeof result === "object" && hasExecutableQueryShape(result)) {
+          return wrapExecutableQuery(result, profiler);
+        }
+        return result;
+      };
+    }
+  };
+  return new Proxy(query, handler);
+}
+function hasExecutableQueryShape(object) {
+  return "toAst" in object && typeof object.toAst === "function" && "execute" in object && typeof object.execute === "function";
+}
+function hasQueryBuilderShape(object) {
+  return "from" in object && typeof object.from === "function" || "select" in object && typeof object.select === "function" || "whereNode" in object && typeof object.whereNode === "function" || "traverse" in object && typeof object.traverse === "function" || // Traversal builder methods
+  "whereEdge" in object && typeof object.whereEdge === "function" || "to" in object && typeof object.to === "function";
+}
+
+exports.ProfileCollector = ProfileCollector;
+exports.QueryProfiler = QueryProfiler;
+exports.extractPropertyAccesses = extractPropertyAccesses;
+exports.generateRecommendations = generateRecommendations;
+exports.getUnindexedFilters = getUnindexedFilters;
+exports.keyToPath = keyToPath;
+exports.pathToKey = pathToKey;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map