pr suggestions

src/index.ts

@@ -18,7 +18,7 @@ import type {
   SimplifiedSchema
 } from './schema-analyzer';
 import * as schemaStats from './stats';
-import { AnyIterable, StandardJSONSchema, MongodbJSONSchema, ExtendedJSONSchema } from './types';
+import { AnyIterable, StandardJSONSchema, MongoDBJSONSchema, ExtendedJSONSchema } from './types';
 import { getCompletedSchemaAnalyzer } from './utils';
 
 /**
@@ -77,7 +77,7 @@ export type {
   SimplifiedSchemaField,
   SimplifiedSchema,
   StandardJSONSchema,
-  MongodbJSONSchema,
+  MongoDBJSONSchema,
   ExtendedJSONSchema
 };
 

src/schema-accessor.ts

@@ -1,14 +1,18 @@
 import { Schema as InternalSchema } from './schema-analyzer';
 import convertors from './schema-convertors';
-import { ExtendedJSONSchema, MongodbJSONSchema, StandardJSONSchema } from './types';
+import { ExtendedJSONSchema, MongoDBJSONSchema, StandardJSONSchema } from './types';
 
 export interface SchemaAccessor {
   getStandardJsonSchema: () => Promise<StandardJSONSchema>;
-  getMongodbJsonSchema: () => Promise<MongodbJSONSchema>;
+  getMongoDBJsonSchema: () => Promise<MongoDBJSONSchema>;
   getExtendedJsonSchema: () => Promise<ExtendedJSONSchema>;
   getInternalSchema: () => Promise<InternalSchema>;
 }
 
+type Options = {
+  signal?: AbortSignal;
+}
+
 /**
  * Accessor for different schema formats.
  * Internal schema is provided at initialization,
@@ -18,31 +22,29 @@ export interface SchemaAccessor {
 export class InternalSchemaBasedAccessor implements SchemaAccessor {
   private internalSchema: InternalSchema;
   private standardJSONSchema?: StandardJSONSchema;
-  private mongodbJSONSchema?: MongodbJSONSchema;
+  private mongodbJSONSchema?: MongoDBJSONSchema;
   private extendedJSONSchema?: ExtendedJSONSchema;
-  private signal?: AbortSignal;
 
-  constructor(internalSchema: InternalSchema, signal?: AbortSignal) {
-    this.signal = signal;
+  constructor(internalSchema: InternalSchema) {
     this.internalSchema = internalSchema;
   }
 
-  async getInternalSchema(): Promise<InternalSchema> {
+  async getInternalSchema(options?: Options): Promise<InternalSchema> {
     return this.internalSchema;
   }
 
-  async getStandardJsonSchema(): Promise<StandardJSONSchema> {
+  async getStandardJsonSchema(options: Options = {}): Promise<StandardJSONSchema> {
     if (this.standardJSONSchema) return this.standardJSONSchema;
-    return this.standardJSONSchema = await convertors.internalSchemaToStandard(this.internalSchema, { signal: this.signal });
+    return this.standardJSONSchema = await convertors.internalSchemaToStandard(this.internalSchema, options);
   }
 
-  async getMongodbJsonSchema(): Promise<MongodbJSONSchema> {
+  async getMongoDBJsonSchema(options: Options = {}): Promise<MongoDBJSONSchema> {
     if (this.mongodbJSONSchema) return this.mongodbJSONSchema;
-    return this.mongodbJSONSchema = await convertors.internalSchemaToMongodb(this.internalSchema, { signal: this.signal });
+    return this.mongodbJSONSchema = await convertors.internalSchemaToMongoDB(this.internalSchema, options);
   }
 
-  async getExtendedJsonSchema(): Promise<ExtendedJSONSchema> {
+  async getExtendedJsonSchema(options: Options = {}): Promise<ExtendedJSONSchema> {
     if (this.extendedJSONSchema) return this.extendedJSONSchema;
-    return this.extendedJSONSchema = await convertors.internalSchemaToExtended(this.internalSchema, { signal: this.signal });
+    return this.extendedJSONSchema = await convertors.internalSchemaToExtended(this.internalSchema, options);
   }
 }

src/schema-analyzer.ts

@@ -17,6 +17,7 @@ import {
 } from 'bson';
 
 import semanticTypes from './semantic-types';
+import { AnyIterable } from './types';
 
 type TypeCastMap = {
   Array: unknown[];
@@ -586,3 +587,28 @@ export class SchemaAnalyzer {
     return simplifiedSchema(this.schemaAnalysisRoot.fields);
   }
 }
+
+export function verifyStreamSource(
+  source: AnyIterable
+): AnyIterable {
+  if (!(Symbol.iterator in source) && !(Symbol.asyncIterator in source)) {
+    throw new Error(
+      'Unknown input type for `docs`. Must be an array, ' +
+        'stream or MongoDB Cursor.'
+    );
+  }
+
+  return source;
+}
+
+export async function getCompletedSchemaAnalyzer(
+  source: AnyIterable,
+  options?: SchemaParseOptions
+): Promise<SchemaAnalyzer> {
+  const analyzer = new SchemaAnalyzer(options);
+  for await (const doc of verifyStreamSource(source)) {
+    if (options?.signal?.aborted) throw options.signal.aborted;
+    analyzer.analyzeDoc(doc);
+  }
+  return analyzer;
+}

src/schema-convertors.ts

@@ -1,5 +1,5 @@
 import { Schema as InternalSchema } from './schema-analyzer';
-import { ExtendedJSONSchema, MongodbJSONSchema, StandardJSONSchema } from './types';
+import { ExtendedJSONSchema, MongoDBJSONSchema, StandardJSONSchema } from './types';
 
 function internalSchemaToStandard(
   internalSchema: InternalSchema,
@@ -10,13 +10,13 @@ function internalSchemaToStandard(
   return {};
 }
 
-function internalSchemaToMongodb(
+function internalSchemaToMongoDB(
   internalSchema: InternalSchema,
   options: {
     signal?: AbortSignal
-}): MongodbJSONSchema {
+}): MongoDBJSONSchema {
   // TODO: COMPASS-8701
-  return {} as MongodbJSONSchema;
+  return {} as MongoDBJSONSchema;
 }
 
 function internalSchemaToExtended(
@@ -30,6 +30,6 @@ function internalSchemaToExtended(
 
 export default {
   internalSchemaToStandard,
-  internalSchemaToMongodb,
+  internalSchemaToMongoDB,
   internalSchemaToExtended
 };