@react-native-firebase/firestore 23.8.8 → 24.0.0

package/lib/web/pipelines/pipeline_node_builder.ts

@@ -0,0 +1,413 @@
+/*
+ * 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 * as firebaseFirestorePipelines from '@react-native-firebase/app/dist/module/internal/web/firebaseFirestorePipelines';
+import type {
+  AggregateFunction,
+  AliasedAggregate,
+  AliasedExpression,
+  Expression,
+  Ordering,
+  Pipeline as WebSdkPipeline,
+  PipelineSource as WebSdkPipelineSource,
+} from '@react-native-firebase/app/dist/module/internal/web/firebaseFirestorePipelines';
+
+export type WebPipelineInstance = WebSdkPipeline & Record<string, unknown>;
+export type WebPipelineSource = WebSdkPipelineSource<WebPipelineInstance> & Record<string, unknown>;
+
+type PipelineHelperFn = (...args: unknown[]) => unknown;
+type AliasedValue = { as: (name: string) => unknown };
+
+const WEB_PIPELINE_HELPER_ALIASES: Record<string, string> = {
+  lower: 'toLower',
+  upper: 'toUpper',
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function getPipelineHelper(name: string): PipelineHelperFn {
+  const helperModule = firebaseFirestorePipelines as Record<string, unknown>;
+  const helper = helperModule[name] ?? helperModule[WEB_PIPELINE_HELPER_ALIASES[name] ?? ''];
+  if (typeof helper !== 'function') {
+    throw new Error(
+      `pipelineExecute() cannot rebuild "${name}" because the web helper is missing.`,
+    );
+  }
+  return helper as PipelineHelperFn;
+}
+
+function isExpressionNode(value: Record<string, unknown>): boolean {
+  return (
+    value.__kind === 'expression' ||
+    value.exprType === 'Field' ||
+    value.exprType === 'Constant' ||
+    value.exprType === 'Function'
+  );
+}
+
+function isFlatAliasedFieldNode(value: Record<string, unknown>): boolean {
+  const alias = value.alias ?? value.as;
+  return (
+    typeof value.path === 'string' &&
+    value.path.length > 0 &&
+    typeof alias === 'string' &&
+    alias.length > 0
+  );
+}
+
+function isAliasedExpressionNode(value: Record<string, unknown>): boolean {
+  const alias = value.alias ?? value.as;
+  return (
+    typeof alias === 'string' &&
+    alias.length > 0 &&
+    Object.prototype.hasOwnProperty.call(value, 'expr')
+  );
+}
+
+function isAliasedAggregateNode(value: Record<string, unknown>): boolean {
+  return (
+    typeof value.alias === 'string' &&
+    value.alias.length > 0 &&
+    Object.prototype.hasOwnProperty.call(value, 'aggregate')
+  );
+}
+
+type ReviveMode = 'pipeline' | 'helper';
+
+type ReviveWorkFrame =
+  | {
+      kind: 'evaluate';
+      mode: ReviveMode;
+      value: unknown;
+      resolve: (result: unknown) => void;
+    }
+  | {
+      kind: 'finalize';
+      run: () => void;
+    };
+
+function rebuildFlatAliasedField(value: Record<string, unknown>): unknown {
+  const alias = (value.alias ?? value.as) as string;
+  const field = getPipelineHelper('field')(value.path) as Expression & Partial<AliasedValue>;
+  const asFn = field.as;
+  if (typeof asFn !== 'function') {
+    throw new Error('pipelineExecute() failed to rebuild flat aliased field for web SDK.');
+  }
+  return asFn.call(field, alias);
+}
+
+function applyAlias(
+  revivedValue: unknown,
+  alias: string,
+  nodeKey: 'expr' | 'aggregate',
+): AliasedExpression | AliasedAggregate {
+  if (
+    !revivedValue ||
+    (typeof revivedValue !== 'object' && typeof revivedValue !== 'function') ||
+    !('as' in revivedValue)
+  ) {
+    throw new Error(`pipelineExecute() failed to rebuild aliased ${nodeKey}: invalid value.`);
+  }
+
+  return (revivedValue as AliasedValue).as(alias) as AliasedExpression | AliasedAggregate;
+}
+
+function rebuildExpressionNode(
+  stack: ReviveWorkFrame[],
+  node: Record<string, unknown>,
+  mode: ReviveMode,
+  resolve: (result: unknown) => void,
+): void {
+  if (node.exprType === 'Field' || typeof node.path === 'string') {
+    resolve(getPipelineHelper('field')(node.path) as Expression);
+    return;
+  }
+
+  if (node.exprType === 'Constant' || Object.prototype.hasOwnProperty.call(node, 'value')) {
+    if (mode === 'helper') {
+      stack.push({
+        kind: 'evaluate',
+        mode,
+        value: node.value,
+        resolve,
+      });
+      return;
+    }
+
+    let revivedValue: unknown;
+    stack.push({
+      kind: 'finalize',
+      run: () => {
+        resolve(getPipelineHelper('constant')(revivedValue) as Expression);
+      },
+    });
+    stack.push({
+      kind: 'evaluate',
+      mode,
+      value: node.value,
+      resolve: result => {
+        revivedValue = result;
+      },
+    });
+    return;
+  }
+
+  if (typeof node.name === 'string') {
+    const helperName = node.name;
+    const args = Array.isArray(node.args) ? node.args : [];
+    const revivedArgs = new Array(args.length);
+    const argsMode = helperName === 'conditional' ? 'pipeline' : 'helper';
+
+    stack.push({
+      kind: 'finalize',
+      run: () => {
+        if (helperName === 'array') {
+          resolve(getPipelineHelper(helperName)(revivedArgs) as Expression);
+          return;
+        }
+        resolve(getPipelineHelper(helperName)(...revivedArgs) as Expression);
+      },
+    });
+
+    for (let i = args.length - 1; i >= 0; i--) {
+      stack.push({
+        kind: 'evaluate',
+        mode: argsMode,
+        value: args[i],
+        resolve: result => {
+          revivedArgs[i] = result;
+        },
+      });
+    }
+    return;
+  }
+
+  throw new Error('pipelineExecute() failed to rebuild a serialized expression node for web SDK.');
+}
+
+function rebuildAggregateNode(
+  stack: ReviveWorkFrame[],
+  node: Record<string, unknown>,
+  resolve: (result: unknown) => void,
+): void {
+  if (typeof node.kind !== 'string') {
+    throw new Error('pipelineExecute() failed to rebuild aggregate node: missing aggregate kind.');
+  }
+
+  const helperName = node.kind;
+  const args = Array.isArray(node.args) ? node.args : [];
+  const revivedArgs = new Array(args.length);
+
+  stack.push({
+    kind: 'finalize',
+    run: () => {
+      resolve(getPipelineHelper(helperName)(...revivedArgs) as AggregateFunction);
+    },
+  });
+
+  for (let i = args.length - 1; i >= 0; i--) {
+    stack.push({
+      kind: 'evaluate',
+      mode: 'helper',
+      value: args[i],
+      resolve: result => {
+        revivedArgs[i] = result;
+      },
+    });
+  }
+}
+
+function rebuildOrderingNode(
+  stack: ReviveWorkFrame[],
+  node: Record<string, unknown>,
+  resolve: (result: unknown) => void,
+): void {
+  if (!Object.prototype.hasOwnProperty.call(node, 'expr')) {
+    throw new Error('pipelineExecute() failed to rebuild ordering node: missing expr.');
+  }
+
+  const direction = node.direction === 'descending' ? 'descending' : 'ascending';
+  let revivedExpr: unknown;
+
+  stack.push({
+    kind: 'finalize',
+    run: () => {
+      resolve(getPipelineHelper(direction)(revivedExpr) as Ordering);
+    },
+  });
+  stack.push({
+    kind: 'evaluate',
+    mode: 'pipeline',
+    value: node.expr,
+    resolve: result => {
+      revivedExpr = result;
+    },
+  });
+}
+
+function rebuildAliasedNode(
+  stack: ReviveWorkFrame[],
+  node: Record<string, unknown>,
+  nodeKey: 'expr' | 'aggregate',
+  resolve: (result: unknown) => void,
+): void {
+  const alias = typeof node.alias === 'string' ? node.alias : undefined;
+  if (!alias) {
+    throw new Error(`pipelineExecute() failed to rebuild aliased node: missing ${nodeKey} alias.`);
+  }
+
+  let revivedValue: unknown;
+  stack.push({
+    kind: 'finalize',
+    run: () => {
+      resolve(applyAlias(revivedValue, alias, nodeKey));
+    },
+  });
+  stack.push({
+    kind: 'evaluate',
+    mode: 'pipeline',
+    value: node[nodeKey],
+    resolve: result => {
+      revivedValue = result;
+    },
+  });
+}
+
+function reviveValueWithMode(value: unknown, mode: ReviveMode): unknown {
+  let finalValue: unknown;
+  const stack: ReviveWorkFrame[] = [
+    {
+      kind: 'evaluate',
+      mode,
+      value,
+      resolve: result => {
+        finalValue = result;
+      },
+    },
+  ];
+
+  while (stack.length > 0) {
+    const frame = stack.pop()!;
+
+    if (frame.kind === 'finalize') {
+      frame.run();
+      continue;
+    }
+
+    const currentValue = frame.value;
+    if (Array.isArray(currentValue)) {
+      const revived = new Array(currentValue.length);
+      frame.resolve(revived);
+      for (let i = currentValue.length - 1; i >= 0; i--) {
+        stack.push({
+          kind: 'evaluate',
+          mode: frame.mode,
+          value: currentValue[i],
+          resolve: result => {
+            revived[i] = result;
+          },
+        });
+      }
+      continue;
+    }
+
+    if (!isRecord(currentValue)) {
+      frame.resolve(currentValue);
+      continue;
+    }
+
+    if (frame.mode === 'helper') {
+      if (
+        isFlatAliasedFieldNode(currentValue) ||
+        isAliasedExpressionNode(currentValue) ||
+        isAliasedAggregateNode(currentValue) ||
+        currentValue.__kind === 'aggregate' ||
+        currentValue.__kind === 'ordering'
+      ) {
+        stack.push({
+          kind: 'evaluate',
+          mode: 'pipeline',
+          value: currentValue,
+          resolve: frame.resolve,
+        });
+        continue;
+      }
+
+      if (isExpressionNode(currentValue)) {
+        rebuildExpressionNode(stack, currentValue, frame.mode, frame.resolve);
+        continue;
+      }
+    } else {
+      if (isFlatAliasedFieldNode(currentValue)) {
+        frame.resolve(rebuildFlatAliasedField(currentValue));
+        continue;
+      }
+
+      if (isAliasedExpressionNode(currentValue)) {
+        rebuildAliasedNode(stack, currentValue, 'expr', frame.resolve);
+        continue;
+      }
+
+      if (isAliasedAggregateNode(currentValue)) {
+        rebuildAliasedNode(stack, currentValue, 'aggregate', frame.resolve);
+        continue;
+      }
+
+      switch (currentValue.__kind) {
+        case 'expression':
+          rebuildExpressionNode(stack, currentValue, frame.mode, frame.resolve);
+          continue;
+        case 'aggregate':
+          rebuildAggregateNode(stack, currentValue, frame.resolve);
+          continue;
+        case 'ordering':
+          rebuildOrderingNode(stack, currentValue, frame.resolve);
+          continue;
+        case 'aliasedExpression':
+          rebuildAliasedNode(stack, currentValue, 'expr', frame.resolve);
+          continue;
+        case 'aliasedAggregate':
+          rebuildAliasedNode(stack, currentValue, 'aggregate', frame.resolve);
+          continue;
+        default:
+      }
+    }
+
+    const revived: Record<string, unknown> = {};
+    frame.resolve(revived);
+    const entries = Object.entries(currentValue);
+    for (let i = entries.length - 1; i >= 0; i--) {
+      const [key, entry] = entries[i]!;
+      stack.push({
+        kind: 'evaluate',
+        mode: frame.mode,
+        value: entry,
+        resolve: result => {
+          revived[key] = result;
+        },
+      });
+    }
+  }
+
+  return finalValue;
+}
+
+export function revivePipelineValue(value: unknown): unknown {
+  return reviveValueWithMode(value, 'pipeline');
+}

package/lib/web/pipelines/pipeline_parser.ts

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file 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.
+ *
+ */
+
+export type { ValidatedPipelineExecuteRequest as WebParsedPipelineRequest } from '../../pipelines/pipeline_validate';
+export {
+  validateExecuteOptions,
+  validatePipelineExecuteRequest as parseWebSdkPipelineRequest,
+  validateSerializedPipeline,
+} from '../../pipelines/pipeline_validate';

package/lib/web/pipelines/pipeline_snapshot_serializer.ts

@@ -0,0 +1,133 @@
+/*
+ * 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 type {
+  FirestorePipelineResultInternal,
+  FirestorePipelineSnapshotInternal,
+  FirestorePipelineTimestampInternal,
+} from '../../types/internal';
+import type { WebParsedPipelineRequest } from './pipeline_parser';
+import { objectToWriteable } from '../convert';
+
+const METADATA_FALLBACK_STAGES = new Set(['select', 'addFields', 'removeFields']);
+
+interface PipelineExecutionMetadata {
+  sourceDocumentPaths: string[];
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function serializeTimestamp(value: unknown): FirestorePipelineTimestampInternal | undefined {
+  if (!value) {
+    return undefined;
+  }
+
+  if (typeof value === 'number') {
+    return value;
+  }
+
+  if (isRecord(value)) {
+    if (typeof value.seconds === 'number' && typeof value.nanoseconds === 'number') {
+      return {
+        seconds: value.seconds,
+        nanoseconds: value.nanoseconds,
+      };
+    }
+
+    if (typeof value.toMillis === 'function') {
+      return (value.toMillis as () => number)();
+    }
+  }
+
+  return undefined;
+}
+
+function buildExecutionMetadata(request: WebParsedPipelineRequest): PipelineExecutionMetadata {
+  if (
+    request.pipeline.source.source === 'documents' &&
+    request.pipeline.source.documents.length > 0 &&
+    request.pipeline.stages.every(stage => METADATA_FALLBACK_STAGES.has(stage.stage))
+  ) {
+    return {
+      sourceDocumentPaths: request.pipeline.source.documents,
+    };
+  }
+
+  return {
+    sourceDocumentPaths: [],
+  };
+}
+
+function getFallbackPath(
+  metadata: PipelineExecutionMetadata,
+  index: number,
+  resultCount: number,
+): string | undefined {
+  if (
+    metadata.sourceDocumentPaths.length === 0 ||
+    metadata.sourceDocumentPaths.length !== resultCount ||
+    index < 0 ||
+    index >= metadata.sourceDocumentPaths.length
+  ) {
+    return undefined;
+  }
+
+  return metadata.sourceDocumentPaths[index];
+}
+
+function serializePipelineResult(
+  result: unknown,
+  fallbackPath?: string,
+): FirestorePipelineResultInternal {
+  const resultRecord = isRecord(result) ? result : {};
+  const ref = isRecord(resultRecord.ref) ? resultRecord.ref : undefined;
+  const path = typeof ref?.path === 'string' ? ref.path : fallbackPath;
+  const rawData = typeof resultRecord.data === 'function' ? resultRecord.data() : resultRecord.data;
+  const idFromPath = path ? path.split('/').pop() : undefined;
+
+  return {
+    data: isRecord(rawData) ? objectToWriteable(rawData) : undefined,
+    path,
+    id: typeof resultRecord.id === 'string' ? resultRecord.id : idFromPath,
+    createTime: serializeTimestamp(resultRecord.createTime),
+    updateTime: serializeTimestamp(resultRecord.updateTime),
+  };
+}
+
+export function serializeWebSdkPipelineSnapshot(
+  rawSnapshot: unknown,
+  request: WebParsedPipelineRequest,
+): FirestorePipelineSnapshotInternal {
+  const metadata = buildExecutionMetadata(request);
+  const snapshotRecord = isRecord(rawSnapshot) ? rawSnapshot : {};
+  const rawResults = Array.isArray(snapshotRecord.results) ? snapshotRecord.results : [];
+  const results = rawResults.map((result, index) =>
+    serializePipelineResult(result, getFallbackPath(metadata, index, rawResults.length)),
+  );
+
+  const executionTime = serializeTimestamp(snapshotRecord.executionTime);
+  if (!executionTime) {
+    throw new Error('pipelineExecute() expected the web SDK snapshot to include executionTime.');
+  }
+
+  return {
+    results,
+    executionTime,
+  };
+}