Implement _validateUserData for search stage

Author: MarkDuckworth

handwritten/firestore/dev/src/pipelines/index.ts

@@ -161,5 +161,8 @@ export {
   switchOn,
   ifNull,
   coalesce,
+  documentMatches,
+  score,
+  geoDistance,
   // TODO(new-expression): Add new expression exports above this line
 } from './expression';

handwritten/firestore/dev/src/pipelines/pipelines.ts

@@ -1428,17 +1428,16 @@ export class Pipeline implements firestore.Pipelines.Pipeline {
    */
   search(options: firestore.Pipelines.SearchStageOptions): Pipeline {
     // Convert user land convenience types to internal types
-    const normalizedQuery: firestore.Pipelines.BooleanExpression = isExpr(
-      options.query,
-    )
-      ? options.query
+    const normalizedQuery: BooleanExpression = isExpr(options.query)
+      ? (options.query as BooleanExpression)
       : documentMatches(options.query);
     // const normalizedSelect: Record<string, Expression> | undefined =
     //   options.select ? selectablesToObject(options.select) : undefined;
     const normalizedAddFields: Record<string, Expression> | undefined =
       options.addFields ? selectablesToObject(options.addFields) : undefined;
-    const normalizedSort: firestore.Pipelines.Ordering[] | undefined =
-      isOrdering(options.sort) ? [options.sort] : options.sort;
+    const normalizedSort: Ordering[] | undefined = isOrdering(options.sort)
+      ? [options.sort as Ordering]
+      : (options.sort as Ordering[]);
 
     const internalOptions: InternalSearchStageOptions = {
       ...options,

handwritten/firestore/dev/src/pipelines/stage.ts

@@ -728,10 +728,10 @@ export type InternalSearchStageOptions = Omit<
   firestore.Pipelines.SearchStageOptions,
   'query' | 'sort' | 'select' | 'addFields'
 > & {
-  query: firestore.Pipelines.BooleanExpression;
-  sort?: Array<firestore.Pipelines.Ordering>;
-  select?: Record<string, firestore.Pipelines.Expression>;
-  addFields?: Record<string, firestore.Pipelines.Expression>;
+  query: BooleanExpression;
+  sort?: Array<Ordering>;
+  select?: Record<string, Expression>;
+  addFields?: Record<string, Expression>;
 };
 
 /**
@@ -742,6 +742,25 @@ export class Search implements Stage {
 
   constructor(private options: InternalSearchStageOptions) {}
 
+  _validateUserData(ignoreUndefinedProperties: boolean): void {
+    validateUserDataHelper(this.options.query, ignoreUndefinedProperties);
+    if (this.options.sort) {
+      validateUserDataHelper(this.options.sort, ignoreUndefinedProperties);
+    }
+    if (this.options.select) {
+      validateUserDataHelper(
+        Object.values(this.options.select) as Expression[],
+        ignoreUndefinedProperties,
+      );
+    }
+    if (this.options.addFields) {
+      validateUserDataHelper(
+        Object.values(this.options.addFields) as Expression[],
+        ignoreUndefinedProperties,
+      );
+    }
+  }
+
   readonly optionsUtil = new OptionsUtil({
     query: {
       serverName: 'query',
@@ -841,7 +860,7 @@ export class DeleteStage implements Stage {
     };
   }
 
-  _validateUserData(ignoreUndefinedProperties: boolean): void {}
+  _validateUserData(_: boolean): void {}
 }
 
 /**

handwritten/firestore/dev/system-test/pipeline.ts

@@ -186,19 +186,19 @@ const timestampDeltaMS = 3000;
 let beginDocCreation = 0;
 let endDocCreation = 0;
 
-  async function testCollectionWithDocs(
-    targetCol: CollectionReference,
-    docs: {
-      [id: string]: DocumentData;
+async function testCollectionWithDocs(
+  targetCol: CollectionReference,
+  docs: {
+    [id: string]: DocumentData;
   },
 ): Promise<CollectionReference<DocumentData>> {
   beginDocCreation = new Date().valueOf();
   for (const id in docs) {
-      const ref = targetCol.doc(id);
+    const ref = targetCol.doc(id);
     await ref.set(docs[id]);
   }
   endDocCreation = new Date().valueOf();
-    return targetCol;
+  return targetCol;
 }
 
 function expectResults(result: PipelineSnapshot, ...docs: string[]): void;
@@ -226,7 +226,7 @@ describe.skipClassic('Pipeline class', () => {
   let randomCol: CollectionReference;
 
   async function setupBookDocs(
-      targetCol: CollectionReference,
+    targetCol: CollectionReference,
   ): Promise<CollectionReference<DocumentData>> {
     const bookDocs: {[id: string]: DocumentData} = {
       book1: {

handwritten/firestore/dev/test/pipelines/stage.ts

@@ -25,6 +25,7 @@ import field = Pipelines.field;
 import sum = Pipelines.sum;
 import descending = Pipelines.descending;
 import constant = Pipelines.constant;
+import documentMatches = Pipelines.documentMatches;
 import IValue = google.firestore.v1.IValue;
 
 const FIRST_CALL = 0;
@@ -357,3 +358,42 @@ describe('stage option serialization', () => {
     });
   });
 });
+
+describe('stage _validateUserData', () => {
+  it('search stage validation', async () => {
+    const firestore = await createInstance();
+
+    // Should throw when ignoreUndefinedProperties is false (default)
+    expect(() => {
+      void firestore
+        .pipeline()
+        .collection('foo')
+        .search({
+          query: documentMatches(undefined as unknown as string),
+        })
+        .execute();
+    }).to.throw(
+      'Value for argument "value" is not a valid constant value. Cannot use "undefined" as a Firestore value',
+    );
+
+    // Should not throw when ignoreUndefinedProperties is true
+    const spy = sinon.fake.returns(stream());
+    const firestoreWithIgnore = await createInstance(
+      {
+        executePipeline: spy,
+      },
+      {
+        ignoreUndefinedProperties: true,
+      },
+    );
+
+    await firestoreWithIgnore
+      .pipeline()
+      .collection('foo')
+      .search({
+        query: 'foo',
+        addFields: [constant({foo: undefined}).as('bar')],
+      })
+      .execute();
+  });
+});