@react-native-firebase/firestore 23.8.6 → 24.0.0

package/lib/web/convert.ts

@@ -0,0 +1,287 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import {
+  DocumentReference,
+  Timestamp,
+  GeoPoint,
+  Bytes,
+  doc,
+  documentId,
+  serverTimestamp,
+  increment,
+  deleteField,
+  arrayUnion,
+  arrayRemove,
+  vector,
+  VectorValue,
+} from '@react-native-firebase/app/dist/module/internal/web/firebaseFirestore';
+import type { Firestore } from '@react-native-firebase/app/dist/module/internal/web/firebaseFirestore';
+
+const INT_NAN = 0;
+const INT_NEGATIVE_INFINITY = 1;
+const INT_POSITIVE_INFINITY = 2;
+const INT_NULL = 3;
+const INT_DOCUMENTID = 4;
+const INT_BOOLEAN_TRUE = 5;
+const INT_BOOLEAN_FALSE = 6;
+const INT_DOUBLE = 7;
+const INT_STRING = 8;
+const INT_STRING_EMPTY = 9;
+const INT_ARRAY = 10;
+const INT_REFERENCE = 11;
+const INT_GEOPOINT = 12;
+const INT_TIMESTAMP = 13;
+const INT_BLOB = 14;
+const INT_FIELDVALUE = 15;
+const INT_OBJECT = 16;
+const INT_INTEGER = 17;
+const INT_NEGATIVE_ZERO = 18;
+const INT_VECTOR = 19;
+const INT_UNKNOWN = -999;
+
+const TYPE = 'type';
+const KEY_PATH = 'path';
+const KEY_DATA = 'data';
+const KEY_OPTIONS = 'options';
+
+export function objectToWriteable(object: Record<string, unknown>): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(object)) {
+    out[key] = buildTypeMap(value);
+  }
+  return out;
+}
+
+export function arrayToWriteable(array: unknown[]): unknown[] {
+  return array.map(buildTypeMap);
+}
+
+export function readableToObject(
+  firestore: Firestore,
+  readableMap: Record<string, unknown>,
+): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(readableMap)) {
+    out[key] = parseTypeMap(firestore, value as [number, unknown?]);
+  }
+  return out;
+}
+
+export function readableToArray(firestore: Firestore, readableArray: unknown[]): unknown[] {
+  return readableArray.map(value => parseTypeMap(firestore, value as [number, unknown?]));
+}
+
+export interface ParsedDocumentBatch {
+  type: string;
+  path: string;
+  data?: Record<string, unknown>;
+  options?: Record<string, unknown>;
+}
+
+export function parseDocumentBatches(
+  firestore: Firestore,
+  readableArray: Array<Record<string, unknown>>,
+): ParsedDocumentBatch[] {
+  const out: ParsedDocumentBatch[] = [];
+
+  for (const map of readableArray) {
+    const write: ParsedDocumentBatch = {
+      [TYPE]: map[TYPE] as string,
+      [KEY_PATH]: map[KEY_PATH] as string,
+    };
+
+    if (KEY_DATA in map) {
+      write.data = readableToObject(firestore, map[KEY_DATA] as Record<string, unknown>);
+    }
+
+    if (KEY_OPTIONS in map) {
+      write.options = map[KEY_OPTIONS] as Record<string, unknown>;
+    }
+
+    out.push(write);
+  }
+
+  return out;
+}
+
+function buildTypeMap(value: unknown): unknown {
+  const out: unknown[] = [];
+  if (value === null) {
+    out.push(INT_NULL);
+    return out;
+  }
+
+  if (typeof value === 'boolean') {
+    out.push(value ? INT_BOOLEAN_TRUE : INT_BOOLEAN_FALSE);
+    return out;
+  }
+
+  if (typeof value === 'number' && !Number.isInteger(value)) {
+    out.push(INT_DOUBLE);
+    out.push(value);
+    return out;
+  }
+
+  if (typeof value === 'number' && Number.isInteger(value)) {
+    if (value === Number.NEGATIVE_INFINITY) {
+      out.push(INT_NEGATIVE_INFINITY);
+      return out;
+    }
+    if (value === Number.POSITIVE_INFINITY) {
+      out.push(INT_POSITIVE_INFINITY);
+      return out;
+    }
+    if (Number.isNaN(value)) {
+      out.push(INT_NAN);
+      return out;
+    }
+    out.push(INT_DOUBLE);
+    out.push(value);
+    return out;
+  }
+
+  if (typeof value === 'string') {
+    if (value === '') {
+      out.push(INT_STRING_EMPTY);
+    } else {
+      out.push(INT_STRING);
+      out.push(value);
+    }
+    return out;
+  }
+
+  if (Array.isArray(value)) {
+    out.push(INT_ARRAY);
+    out.push(arrayToWriteable(value));
+    return out;
+  }
+
+  if (value instanceof DocumentReference) {
+    out.push(INT_REFERENCE);
+    out.push(value.path);
+    return out;
+  }
+
+  if (value instanceof Timestamp) {
+    out.push(INT_TIMESTAMP);
+    out.push([value.seconds, value.nanoseconds]);
+    return out;
+  }
+
+  if (value instanceof GeoPoint) {
+    out.push(INT_GEOPOINT);
+    out.push([value.latitude, value.longitude]);
+    return out;
+  }
+
+  if (value instanceof Bytes) {
+    out.push(INT_BLOB);
+    out.push(value.toBase64());
+    return out;
+  }
+
+  if (value instanceof VectorValue) {
+    out.push(INT_VECTOR);
+    out.push(value.toArray());
+    return out;
+  }
+
+  if (typeof value === 'object') {
+    out.push(INT_OBJECT);
+    out.push(objectToWriteable(value as Record<string, unknown>));
+    return out;
+  }
+
+  out.push(INT_UNKNOWN);
+  return out;
+}
+
+export function parseTypeMap(firestore: Firestore, typedArray: [number, unknown?]): unknown {
+  const value = typedArray[0];
+
+  switch (value) {
+    case INT_NAN:
+      return NaN;
+    case INT_NEGATIVE_INFINITY:
+      return Number.NEGATIVE_INFINITY;
+    case INT_POSITIVE_INFINITY:
+      return Number.POSITIVE_INFINITY;
+    case INT_NULL:
+      return null;
+    case INT_DOCUMENTID:
+      return documentId();
+    case INT_BOOLEAN_TRUE:
+      return true;
+    case INT_BOOLEAN_FALSE:
+      return false;
+    case INT_NEGATIVE_ZERO:
+      return -0;
+    case INT_INTEGER:
+      return Number(typedArray[1]);
+    case INT_DOUBLE:
+      return Number(typedArray[1]);
+    case INT_STRING:
+      return String(typedArray[1]);
+    case INT_STRING_EMPTY:
+      return '';
+    case INT_ARRAY:
+      return readableToArray(firestore, (typedArray[1] ?? []) as unknown[]);
+    case INT_REFERENCE:
+      return doc(firestore, typedArray[1] as string);
+    case INT_GEOPOINT: {
+      const v = (typedArray[1] ?? []) as number[];
+      return new GeoPoint(v[0] ?? 0, v[1] ?? 0);
+    }
+    case INT_TIMESTAMP: {
+      const v = (typedArray[1] ?? []) as number[];
+      return new Timestamp(v[0] ?? 0, v[1] ?? 0);
+    }
+    case INT_BLOB:
+      return Bytes.fromBase64String(typedArray[1] as string);
+    case INT_FIELDVALUE: {
+      const fieldValueArray = (typedArray[1] ?? []) as unknown[];
+      const fieldValueType = fieldValueArray[0];
+
+      if (fieldValueType === 'timestamp') {
+        return serverTimestamp();
+      }
+      if (fieldValueType === 'increment') {
+        return increment(fieldValueArray[1] as number);
+      }
+      if (fieldValueType === 'delete') {
+        return deleteField();
+      }
+      if (fieldValueType === 'array_union') {
+        const elements = readableToArray(firestore, (fieldValueArray[1] ?? []) as unknown[]);
+        return arrayUnion(...elements);
+      }
+      if (fieldValueType === 'array_remove') {
+        const elements = readableToArray(firestore, (fieldValueArray[1] ?? []) as unknown[]);
+        return arrayRemove(...elements);
+      }
+      return null;
+    }
+    case INT_OBJECT:
+      return readableToObject(firestore, (typedArray[1] ?? {}) as Record<string, unknown>);
+    case INT_VECTOR:
+      return vector(typedArray[1] as number[]);
+    case INT_UNKNOWN:
+    default:
+      return null;
+  }
+}

package/lib/web/pipelines/pipeline.ts

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import { execute } from '@react-native-firebase/app/dist/module/internal/web/firebaseFirestorePipelines';
+import type { Firestore } from '@react-native-firebase/app/dist/module/internal/web/firebaseFirestore';
+import type {
+  FirestorePipelineExecuteOptionsInternal,
+  FirestorePipelineSerializedInternal,
+  FirestorePipelineSnapshotInternal,
+} from '../../types/internal';
+import { validatePipelineExecuteRequest } from '../../pipelines/pipeline_validate';
+import { buildWebSdkPipeline } from './pipeline_bridge_factory';
+import type { WebPipelineInstance } from './pipeline_node_builder';
+import { serializeWebSdkPipelineSnapshot } from './pipeline_snapshot_serializer';
+
+async function executeWebSdkPipelineSnapshot(
+  webSdkPipeline: WebPipelineInstance,
+  _options?: FirestorePipelineExecuteOptionsInternal,
+): Promise<unknown> {
+  // The current web SDK execute() surface only accepts the pipeline instance.
+  return execute(webSdkPipeline);
+}
+
+export async function executeWebSdkPipeline(
+  firestore: Firestore,
+  pipeline: FirestorePipelineSerializedInternal,
+  options?: FirestorePipelineExecuteOptionsInternal,
+): Promise<FirestorePipelineSnapshotInternal> {
+  const request = validatePipelineExecuteRequest(pipeline, options);
+  const webSdkPipeline = buildWebSdkPipeline(firestore, request);
+  const rawSnapshot = await executeWebSdkPipelineSnapshot(webSdkPipeline, request.options);
+  return serializeWebSdkPipelineSnapshot(rawSnapshot, request);
+}

package/lib/web/pipelines/pipeline_bridge_factory.ts

@@ -0,0 +1,377 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import {
+  collection,
+  collectionGroup,
+} from '@react-native-firebase/app/dist/module/internal/web/firebaseFirestore';
+import type {
+  Firestore,
+  Query,
+} from '@react-native-firebase/app/dist/module/internal/web/firebaseFirestore';
+import type { FirestorePipelineSerializedInternal } from '../../types/internal';
+import {
+  revivePipelineValue,
+  type WebPipelineInstance,
+  type WebPipelineSource,
+} from './pipeline_node_builder';
+import type { WebParsedPipelineRequest } from './pipeline_parser';
+import { buildQuery } from '../query';
+import type { FilterSpec, OrderSpec, QueryOptions } from '../query';
+
+const PIPELINE_RUNTIME_IMPORT_SUFFIX =
+  ' Import "@react-native-firebase/firestore/pipelines" before using pipelines so the pipeline runtime is installed.';
+
+function createPipelineRuntimeImportError(message: string): Error {
+  return new Error(message + PIPELINE_RUNTIME_IMPORT_SUFFIX);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function buildCollectionSourcePipeline(
+  pipelineSource: WebPipelineSource,
+  source: Extract<FirestorePipelineSerializedInternal['source'], { source: 'collection' }>,
+): WebPipelineInstance | undefined {
+  if (typeof pipelineSource.collection !== 'function') {
+    return undefined;
+  }
+
+  return pipelineSource.collection({
+    collection: source.path,
+    ...(isRecord(source.rawOptions) && source.rawOptions ? { rawOptions: source.rawOptions } : {}),
+  }) as WebPipelineInstance;
+}
+
+function buildCollectionGroupSourcePipeline(
+  pipelineSource: WebPipelineSource,
+  source: Extract<FirestorePipelineSerializedInternal['source'], { source: 'collectionGroup' }>,
+): WebPipelineInstance | undefined {
+  if (typeof pipelineSource.collectionGroup !== 'function') {
+    return undefined;
+  }
+
+  return pipelineSource.collectionGroup({
+    collectionId: source.collectionId,
+    ...(isRecord(source.rawOptions) && source.rawOptions ? { rawOptions: source.rawOptions } : {}),
+  }) as WebPipelineInstance;
+}
+
+function buildDatabaseSourcePipeline(
+  pipelineSource: WebPipelineSource,
+  source: Extract<FirestorePipelineSerializedInternal['source'], { source: 'database' }>,
+): WebPipelineInstance | undefined {
+  if (typeof pipelineSource.database !== 'function') {
+    return undefined;
+  }
+
+  return pipelineSource.database(
+    isRecord(source.rawOptions) && source.rawOptions ? { rawOptions: source.rawOptions } : {},
+  ) as WebPipelineInstance;
+}
+
+function buildDocumentsSourcePipeline(
+  pipelineSource: WebPipelineSource,
+  source: Extract<FirestorePipelineSerializedInternal['source'], { source: 'documents' }>,
+): WebPipelineInstance | undefined {
+  if (typeof pipelineSource.documents !== 'function') {
+    return undefined;
+  }
+
+  return pipelineSource.documents({
+    docs: source.documents,
+    ...(isRecord(source.rawOptions) && source.rawOptions ? { rawOptions: source.rawOptions } : {}),
+  }) as WebPipelineInstance;
+}
+
+function buildQuerySourcePipeline(
+  firestore: Firestore,
+  pipelineSource: WebPipelineSource,
+  source: Extract<FirestorePipelineSerializedInternal['source'], { source: 'query' }>,
+): WebPipelineInstance {
+  if (typeof pipelineSource.createFrom !== 'function') {
+    throw createPipelineRuntimeImportError(
+      'pipelineExecute() expected pipeline source to support createFrom(query).',
+    );
+  }
+
+  const queryRef =
+    source.queryType === 'collectionGroup'
+      ? (collectionGroup(firestore, source.path) as unknown as Query)
+      : (collection(firestore, source.path) as unknown as Query);
+  const query = buildQuery(
+    queryRef,
+    source.filters as FilterSpec[],
+    source.orders as OrderSpec[],
+    source.options as QueryOptions,
+  );
+
+  return pipelineSource.createFrom(query as unknown as Query) as WebPipelineInstance;
+}
+
+function getPipelineStageMethod(
+  current: WebPipelineInstance,
+  stageName: string,
+): (this: WebPipelineInstance, ...args: unknown[]) => unknown {
+  const method = current?.[stageName] as
+    | ((this: WebPipelineInstance, ...args: unknown[]) => unknown)
+    | undefined;
+  if (typeof method !== 'function') {
+    throw new Error(`Pipeline stage "${stageName}" is not supported by the current web SDK.`);
+  }
+  return method;
+}
+
+function applyPipelineStage(
+  current: WebPipelineInstance,
+  stage: FirestorePipelineSerializedInternal['stages'][number],
+  nestedUnionPipeline?: WebPipelineInstance,
+): WebPipelineInstance {
+  if (stage.stage === 'union') {
+    return getPipelineStageMethod(current, stage.stage).call(current, {
+      other: nestedUnionPipeline,
+    }) as WebPipelineInstance;
+  }
+
+  const revivedStageOptions = revivePipelineValue(stage.options);
+  const stageArgs = (isRecord(revivedStageOptions) ? revivedStageOptions : stage.options) as Record<
+    string,
+    unknown
+  >;
+  const method = getPipelineStageMethod(current, stage.stage);
+
+  switch (stage.stage) {
+    case 'where':
+      if (isRecord(stageArgs.condition) && typeof stageArgs.condition.operator === 'string') {
+        const op = stageArgs.condition.operator.toUpperCase();
+        const isArrayOperator =
+          op === 'IN' ||
+          op === 'NOT_IN' ||
+          op === 'ARRAY_CONTAINS_ANY' ||
+          op === 'ARRAY_CONTAINS_ALL';
+        if (isArrayOperator && !Array.isArray(stageArgs.condition.value)) {
+          throw new Error('invalid argument');
+        }
+      }
+      return (
+        stageArgs.condition !== undefined
+          ? method.call(current, stageArgs.condition)
+          : method.call(current, stageArgs)
+      ) as WebPipelineInstance;
+    case 'select':
+      return (
+        Array.isArray(stageArgs.selections)
+          ? method.call(current, ...stageArgs.selections)
+          : method.call(current, stageArgs)
+      ) as WebPipelineInstance;
+    case 'addFields':
+      return (
+        Array.isArray(stageArgs.fields)
+          ? method.call(current, ...stageArgs.fields)
+          : method.call(current, stageArgs)
+      ) as WebPipelineInstance;
+    case 'removeFields':
+      return (
+        Array.isArray(stageArgs.fields)
+          ? method.call(current, ...stageArgs.fields)
+          : method.call(current, stageArgs)
+      ) as WebPipelineInstance;
+    case 'sort':
+      return (
+        Array.isArray(stageArgs.orderings)
+          ? method.call(current, ...stageArgs.orderings)
+          : method.call(current, stageArgs)
+      ) as WebPipelineInstance;
+    case 'limit':
+      return (
+        typeof stageArgs.limit === 'number'
+          ? method.call(current, stageArgs.limit)
+          : method.call(current, stageArgs)
+      ) as WebPipelineInstance;
+    case 'offset':
+      return (
+        typeof stageArgs.offset === 'number'
+          ? method.call(current, stageArgs.offset)
+          : method.call(current, stageArgs)
+      ) as WebPipelineInstance;
+    case 'distinct':
+      return (
+        Array.isArray(stageArgs.groups)
+          ? method.call(current, ...stageArgs.groups)
+          : method.call(current, stageArgs)
+      ) as WebPipelineInstance;
+    case 'aggregate':
+      return method.call(current, stageArgs) as WebPipelineInstance;
+    case 'replaceWith':
+      return (
+        stageArgs.map !== undefined
+          ? method.call(current, stageArgs.map)
+          : method.call(current, stageArgs)
+      ) as WebPipelineInstance;
+    case 'sample':
+      return (
+        typeof stageArgs.documents === 'number'
+          ? method.call(current, stageArgs.documents)
+          : method.call(current, stageArgs)
+      ) as WebPipelineInstance;
+    case 'unnest':
+      return (
+        stageArgs.selectable !== undefined
+          ? method.call(current, stageArgs.selectable, stageArgs.indexField)
+          : method.call(current, stageArgs)
+      ) as WebPipelineInstance;
+    case 'rawStage':
+      return (
+        typeof stageArgs.name === 'string'
+          ? method.call(
+              current,
+              stageArgs.name,
+              stageArgs.params,
+              isRecord(stageArgs.options) ? stageArgs.options : undefined,
+            )
+          : method.call(current, stageArgs)
+      ) as WebPipelineInstance;
+    default:
+      return method.call(current, stageArgs) as WebPipelineInstance;
+  }
+}
+
+function buildSourcePipeline(
+  firestore: Firestore,
+  pipelineFactory: () => unknown,
+  pipeline: FirestorePipelineSerializedInternal,
+): WebPipelineInstance {
+  const pipelineSource = pipelineFactory.call(firestore) as WebPipelineSource;
+  const source = pipeline.source;
+  let currentPipeline: WebPipelineInstance | undefined;
+
+  switch (source.source) {
+    case 'collection':
+      currentPipeline = buildCollectionSourcePipeline(pipelineSource, source);
+      break;
+    case 'collectionGroup':
+      currentPipeline = buildCollectionGroupSourcePipeline(pipelineSource, source);
+      break;
+    case 'database':
+      currentPipeline = buildDatabaseSourcePipeline(pipelineSource, source);
+      break;
+    case 'documents':
+      currentPipeline = buildDocumentsSourcePipeline(pipelineSource, source);
+      break;
+    case 'query':
+      currentPipeline = buildQuerySourcePipeline(firestore, pipelineSource, source);
+      break;
+    default:
+      throw new Error('pipelineExecute() received an unknown source type.');
+  }
+
+  if (!currentPipeline) {
+    throw new Error(
+      `pipelineExecute() failed to construct source stage "${String(source.source)}" for web SDK.`,
+    );
+  }
+
+  return currentPipeline;
+}
+
+type PipelineBuildFrame = {
+  kind: 'pipeline';
+  pipeline: FirestorePipelineSerializedInternal;
+  currentPipeline: WebPipelineInstance;
+  stageIndex: number;
+};
+
+type UnionBuildFrame = {
+  kind: 'union';
+  parent: PipelineBuildFrame;
+  stage: Extract<FirestorePipelineSerializedInternal['stages'][number], { stage: 'union' }>;
+  method: (this: WebPipelineInstance, ...args: unknown[]) => unknown;
+};
+
+export function buildWebSdkPipeline(
+  firestore: Firestore,
+  request: Pick<WebParsedPipelineRequest, 'pipeline'>,
+): WebPipelineInstance {
+  const pipelineFactory = (firestore as { pipeline?: () => unknown }).pipeline;
+  if (typeof pipelineFactory !== 'function') {
+    throw createPipelineRuntimeImportError(
+      'pipelineExecute() expected a Firestore instance with pipeline() support.',
+    );
+  }
+
+  const stack: Array<PipelineBuildFrame | UnionBuildFrame> = [
+    {
+      kind: 'pipeline',
+      pipeline: request.pipeline,
+      currentPipeline: buildSourcePipeline(firestore, pipelineFactory, request.pipeline),
+      stageIndex: 0,
+    },
+  ];
+  let lastCompletedPipeline: WebPipelineInstance | undefined;
+
+  while (stack.length > 0) {
+    const frame = stack[stack.length - 1]!;
+
+    if (frame.kind === 'union') {
+      if (!lastCompletedPipeline) {
+        throw new Error('pipelineExecute() failed to rebuild nested union pipeline for web SDK.');
+      }
+
+      frame.parent.currentPipeline = frame.method.call(frame.parent.currentPipeline, {
+        other: lastCompletedPipeline,
+      }) as WebPipelineInstance;
+      frame.parent.stageIndex += 1;
+      lastCompletedPipeline = undefined;
+      stack.pop();
+      continue;
+    }
+
+    if (frame.stageIndex >= frame.pipeline.stages.length) {
+      lastCompletedPipeline = frame.currentPipeline;
+      stack.pop();
+      continue;
+    }
+
+    const stage = frame.pipeline.stages[frame.stageIndex]!;
+    if (stage.stage !== 'union') {
+      frame.currentPipeline = applyPipelineStage(frame.currentPipeline, stage);
+      frame.stageIndex += 1;
+      continue;
+    }
+
+    const unionPipeline = stage.options.other as FirestorePipelineSerializedInternal;
+    stack.push({
+      kind: 'union',
+      parent: frame,
+      stage,
+      method: getPipelineStageMethod(frame.currentPipeline, stage.stage),
+    });
+    stack.push({
+      kind: 'pipeline',
+      pipeline: unionPipeline,
+      currentPipeline: buildSourcePipeline(firestore, pipelineFactory, unionPipeline),
+      stageIndex: 0,
+    });
+  }
+
+  if (!lastCompletedPipeline) {
+    throw new Error('pipelineExecute() failed to rebuild a pipeline for web SDK.');
+  }
+
+  return lastCompletedPipeline;
+}