Address comment

Author: jcobis

packages/compass-collection/src/schema-analysis-types.ts

@@ -1,14 +1,5 @@
 import type { Document } from 'mongodb';
 import type { PrimitiveSchemaType } from 'mongodb-schema';
-import type {
-  ObjectId,
-  Binary,
-  BSONRegExp,
-  Code,
-  Timestamp,
-  MaxKey,
-  MinKey,
-} from 'bson';
 
 export const SCHEMA_ANALYSIS_STATE_INITIAL = 'initial';
 export const SCHEMA_ANALYSIS_STATE_ANALYZING = 'analyzing';
@@ -49,17 +40,10 @@ export type MongoDBFieldType = PrimitiveSchemaType['name'];
  * These are the JavaScript primitive equivalents of BSON values.
  */
 export type SampleValue =
-  | string
-  | number
+  | string // String, Symbol, ObjectId, Binary, RegExp, Code, etc. (converted to string)
+  | number // Number, Int32, Long, Double, Decimal128, Timestamp (converted via valueOf())
   | boolean
   | Date
-  | ObjectId
-  | Binary
-  | BSONRegExp
-  | Code
-  | Timestamp
-  | MaxKey
-  | MinKey
   | null
   | undefined;
 

packages/compass-collection/src/transform-schema-to-field-info.spec.ts

@@ -474,47 +474,47 @@ describe('processSchema', function () {
     expect(result).to.deep.equal({
       objectId: {
         type: 'ObjectId',
-        sample_values: [new ObjectId('642d766b7300158b1f22e972')],
+        sample_values: ['642d766b7300158b1f22e972'],
         probability: 1.0,
       },
       binary: {
         type: 'Binary',
-        sample_values: [new Binary(Buffer.from('test'))],
+        sample_values: ['dGVzdA=='],
         probability: 1.0,
       },
       regex: {
         type: 'RegExp',
-        sample_values: [new BSONRegExp('pattern', 'i')],
+        sample_values: ['pattern'],
         probability: 1.0,
       },
       code: {
         type: 'Code',
-        sample_values: [new Code('function() {}')],
+        sample_values: ['function() {}'],
         probability: 1.0,
       },
       long: {
         type: 'Long',
-        sample_values: [Long.fromNumber(123456789)],
+        sample_values: [123456789],
         probability: 1.0,
       },
       decimal: {
         type: 'Decimal128',
-        sample_values: [Decimal128.fromString('123.456')],
+        sample_values: [123.456],
         probability: 1.0,
       },
       timestamp: {
         type: 'Timestamp',
-        sample_values: [new Timestamp({ t: 1, i: 1 })],
+        sample_values: [4294967297],
         probability: 1.0,
       },
       maxKey: {
         type: 'MaxKey',
-        sample_values: [new MaxKey()],
+        sample_values: ['MaxKey'],
         probability: 1.0,
       },
       minKey: {
         type: 'MinKey',
-        sample_values: [new MinKey()],
+        sample_values: ['MinKey'],
         probability: 1.0,
       },
       symbol: {

packages/compass-collection/src/transform-schema-to-field-info.ts

@@ -8,6 +8,18 @@ import type {
   ConstantSchemaType,
 } from 'mongodb-schema';
 import type { FieldInfo, SampleValue } from './schema-analysis-types';
+import {
+  ObjectId,
+  Binary,
+  BSONRegExp,
+  Code,
+  Timestamp,
+  MaxKey,
+  MinKey,
+  BSONSymbol,
+  Long,
+  Decimal128,
+} from 'bson';
 
 /**
  * This module transforms mongodb-schema output into a flat, LLM-friendly format using
@@ -32,6 +44,61 @@ import type { FieldInfo, SampleValue } from './schema-analysis-types';
  */
 const MAX_SAMPLE_VALUES = 10;
 
+/**
+ * Converts a BSON value to its primitive JavaScript equivalent
+ */
+function convertBSONToPrimitive(value: unknown): SampleValue {
+  // Handle null/undefined
+  if (value === null || value === undefined) {
+    return value;
+  }
+
+  // Keep Date as-is
+  if (value instanceof Date) {
+    return value;
+  }
+
+  // Convert BSON objects to primitives
+  if (value instanceof ObjectId) {
+    return value.toString();
+  }
+  if (value instanceof Binary) {
+    return value.toString('base64');
+  }
+  if (value instanceof BSONRegExp) {
+    return value.pattern;
+  }
+  if (value instanceof Code) {
+    return value.code;
+  }
+  if (value instanceof Timestamp) {
+    return value.toNumber();
+  }
+  if (value instanceof MaxKey) {
+    return 'MaxKey';
+  }
+  if (value instanceof MinKey) {
+    return 'MinKey';
+  }
+  if (value instanceof BSONSymbol) {
+    return value.toString();
+  }
+  if (value instanceof Long) {
+    return value.toNumber();
+  }
+  if (value instanceof Decimal128) {
+    return parseFloat(value.toString());
+  }
+
+  // Handle objects with valueOf method (numeric types)
+  if (value && typeof value === 'object' && 'valueOf' in value) {
+    const result = (value as { valueOf(): unknown }).valueOf();
+    return result as SampleValue;
+  }
+
+  return value as SampleValue;
+}
+
 function isConstantSchemaType(type: SchemaType): type is ConstantSchemaType {
   return type.name === 'Null' || type.name === 'Undefined';
 }
@@ -129,16 +196,9 @@ function processType(
     // Primitive: Create entry
     const fieldInfo: FieldInfo = {
       type: type.name,
-      sample_values: type.values.slice(0, MAX_SAMPLE_VALUES).map((value) => {
-        // Convert BSON values to their primitive equivalents, but keep Date objects as-is
-        if (value instanceof Date) {
-          return value;
-        }
-        if (value && typeof value === 'object' && 'valueOf' in value) {
-          return value.valueOf();
-        }
-        return value;
-      }) as SampleValue[],
+      sample_values: type.values
+        .slice(0, MAX_SAMPLE_VALUES)
+        .map(convertBSONToPrimitive),
       probability: fieldProbability,
     };