convex-cms 0.0.9-alpha.9 → 0.0.10

package/admin-dist/server/_libs/convex-helpers.mjs

@@ -1,4 +1,4 @@
-import { v } from "./convex.mjs";
+import { v, j as jsonToConvex, c as convexToJson, a as compareValues } from "./convex.mjs";
 function omit(obj, keys) {
   return Object.fromEntries(Object.entries(obj).filter(([k]) => !keys.includes(k)));
 }
@@ -31,7 +31,1082 @@ const doc = (schema, tableName) => {
   return addSystemFields(schema.tables[tableName].validator);
 };
 v.optional(v.any());
+function makeExclusive(boundType) {
+  if (boundType === "gt" || boundType === "gte") {
+    return "gt";
+  }
+  return "lt";
+}
+function splitRange(indexFields, order, startBound, endBound, startBoundType, endBoundType) {
+  const commonPrefix2 = [];
+  while (startBound.length > 0 && endBound.length > 0 && compareValues(startBound[0], endBound[0]) === 0) {
+    const indexField = indexFields[0];
+    indexFields = indexFields.slice(1);
+    const eqBound = startBound[0];
+    startBound = startBound.slice(1);
+    endBound = endBound.slice(1);
+    commonPrefix2.push(["eq", indexField, eqBound]);
+  }
+  const makeCompare = (boundType, key) => {
+    const range = commonPrefix2.slice();
+    let i = 0;
+    for (; i < key.length - 1; i++) {
+      range.push(["eq", indexFields[i], key[i]]);
+    }
+    if (i < key.length) {
+      range.push([boundType, indexFields[i], key[i]]);
+    }
+    return range;
+  };
+  const startRanges = [];
+  while (startBound.length > 1) {
+    startRanges.push(makeCompare(startBoundType, startBound));
+    startBoundType = makeExclusive(startBoundType);
+    startBound = startBound.slice(0, -1);
+  }
+  const endRanges = [];
+  while (endBound.length > 1) {
+    endRanges.push(makeCompare(endBoundType, endBound));
+    endBoundType = makeExclusive(endBoundType);
+    endBound = endBound.slice(0, -1);
+  }
+  endRanges.reverse();
+  let middleRange;
+  if (endBound.length === 0) {
+    middleRange = makeCompare(startBoundType, startBound);
+  } else if (startBound.length === 0) {
+    middleRange = makeCompare(endBoundType, endBound);
+  } else {
+    const startValue = startBound[0];
+    const endValue = endBound[0];
+    middleRange = commonPrefix2.slice();
+    middleRange.push([startBoundType, indexFields[0], startValue]);
+    middleRange.push([endBoundType, indexFields[0], endValue]);
+  }
+  const ranges = [...startRanges, middleRange, ...endRanges];
+  if (order === "desc") {
+    ranges.reverse();
+  }
+  return ranges;
+}
+function rangeToQuery(range) {
+  return (q) => {
+    for (const [boundType, field, value] of range) {
+      q = q[boundType](field, value);
+    }
+    return q;
+  };
+}
+function getIndexFields(table, index, schema) {
+  const indexDescriptor = String(index ?? "by_creation_time");
+  if (indexDescriptor === "by_creation_time") {
+    return ["_creationTime", "_id"];
+  }
+  if (indexDescriptor === "by_id") {
+    return ["_id"];
+  }
+  if (!schema) {
+    throw new Error("schema is required to infer index fields");
+  }
+  const tableInfo = schema.tables[table];
+  const indexInfo = tableInfo.indexes.find((index2) => index2.indexDescriptor === indexDescriptor);
+  if (!indexInfo) {
+    throw new Error(`Index ${indexDescriptor} not found in table ${table}`);
+  }
+  const fields = indexInfo.fields.slice();
+  fields.push("_creationTime");
+  fields.push("_id");
+  return fields;
+}
+function getIndexKey(doc2, indexFields) {
+  const key = [];
+  for (const field of indexFields) {
+    let obj = doc2;
+    for (const subfield of field.split(".")) {
+      obj = obj[subfield];
+    }
+    key.push(obj);
+  }
+  return key;
+}
+function stream(db, schema) {
+  return new StreamDatabaseReader(db, schema);
+}
+class QueryStream {
+  /// Methods for creating new streams as modifications of the current stream.
+  /**
+   * Create a new stream with a TypeScript filter applied.
+   *
+   * This is similar to `db.query(tableName).filter(predicate)`, but it's more
+   * general because it can call arbitrary TypeScript code, including more
+   * database queries.
+   *
+   * All documents filtered out are still considered "read" from the database;
+   * they are just excluded from the output stream.
+   *
+   * In contrast to `filter` from convex-helpers/server/filter, this filterWith
+   * is applied *before* any pagination. That means if the filter excludes a lot
+   * of documents, the `.paginate()` method will read a lot of documents until
+   * it gets as many documents as it wants. If you run into issues with reading
+   * too much data, you can pass `maximumRowsRead` to `paginate()`.
+   */
+  filterWith(predicate) {
+    const order = this.getOrder();
+    return new FlatMapStream(this, async (doc2) => {
+      const filtered = await predicate(doc2) ? doc2 : null;
+      return new SingletonStream(filtered, order, [], [], []);
+    }, []);
+  }
+  /**
+   * Create a new stream where each element is the result of applying the mapper
+   * function to the elements of the original stream.
+   *
+   * Similar to how [1, 2, 3].map(x => x * 2) => [2, 4, 6]
+   */
+  map(mapper) {
+    const order = this.getOrder();
+    return new FlatMapStream(this, async (doc2) => {
+      const mapped = await mapper(doc2);
+      return new SingletonStream(mapped, order, [], [], []);
+    }, []);
+  }
+  /**
+   * Similar to flatMap on an array, but iterate over a stream, and the for each
+   * element, iterate over the stream created by the mapper function.
+   *
+   * Ordered by the original stream order, then the mapped stream. Similar to
+   * how ["a", "b"].flatMap(letter => [letter, letter]) => ["a", "a", "b", "b"]
+   *
+   * @param mapper A function that takes a document and returns a new stream.
+   * @param mappedIndexFields The index fields of the streams created by mapper.
+   * @returns A stream of documents returned by the mapper streams,
+   *   grouped by the documents in the original stream.
+   */
+  flatMap(mapper, mappedIndexFields) {
+    normalizeIndexFields(mappedIndexFields);
+    return new FlatMapStream(this, mapper, mappedIndexFields);
+  }
+  /**
+   * Get the first item from the original stream for each distinct value of the
+   * selected index fields.
+   *
+   * e.g. if the stream has an equality filter on `a`, and index fields `[a, b, c]`,
+   * we can do `stream.distinct(["b"])` to get a stream of the first item for
+   * each distinct value of `b`.
+   * Similarly, you could do `stream.distinct(["a", "b"])` with the same result,
+   * or `stream.distinct(["a", "b", "c"])` to get the original stream.
+   *
+   * This stream efficiently skips past items with the same value for the selected
+   * distinct index fields.
+   *
+   * This can be used to perform a loose index scan.
+   */
+  distinct(distinctIndexFields) {
+    return new DistinctStream(this, distinctIndexFields);
+  }
+  /// Implementation of OrderedQuery
+  filter(_predicate) {
+    throw new Error("Cannot call .filter() directly on a query stream. Use .filterWith() for filtering or .collect() if you want to convert the stream to an array first.");
+  }
+  async paginate(opts) {
+    if (opts.numItems === 0) {
+      if (opts.cursor === null) {
+        throw new Error(".paginate called with cursor of null and 0 for numItems. This is not supported, as null is not a valid continueCursor. Advice: avoid calling paginate entirely in these cases.");
+      }
+      return {
+        page: [],
+        isDone: false,
+        continueCursor: opts.cursor
+      };
+    }
+    const order = this.getOrder();
+    let newStartKey = {
+      key: [],
+      inclusive: true
+    };
+    if (opts.cursor !== null) {
+      newStartKey = {
+        key: deserializeCursor(opts.cursor),
+        inclusive: false
+      };
+    }
+    let newEndKey = {
+      key: [],
+      inclusive: true
+    };
+    const maxRowsToRead = opts.maximumRowsRead;
+    const softMaxRowsToRead = opts.numItems + 1;
+    let maxRows = opts.numItems;
+    if (opts.endCursor) {
+      newEndKey = {
+        key: deserializeCursor(opts.endCursor),
+        inclusive: true
+      };
+      maxRows = void 0;
+    }
+    const newLowerBound = order === "asc" ? newStartKey : newEndKey;
+    const newUpperBound = order === "asc" ? newEndKey : newStartKey;
+    const narrowStream = this.narrow({
+      lowerBound: newLowerBound.key,
+      lowerBoundInclusive: newLowerBound.inclusive,
+      upperBound: newUpperBound.key,
+      upperBoundInclusive: newUpperBound.inclusive
+    });
+    const page = [];
+    const indexKeys = [];
+    let hasMore = opts.endCursor && opts.endCursor !== "[]";
+    let continueCursor = opts.endCursor ?? "[]";
+    for await (const [doc2, indexKey] of narrowStream.iterWithKeys()) {
+      if (doc2 !== null) {
+        page.push(doc2);
+      }
+      indexKeys.push(indexKey);
+      if (maxRows !== void 0 && page.length >= maxRows || maxRowsToRead !== void 0 && indexKeys.length >= maxRowsToRead) {
+        hasMore = true;
+        continueCursor = serializeCursor(indexKey);
+        break;
+      }
+    }
+    let pageStatus = void 0;
+    let splitCursor = void 0;
+    if (indexKeys.length === maxRowsToRead) {
+      pageStatus = "SplitRequired";
+      splitCursor = indexKeys[Math.floor((indexKeys.length - 1) / 2)];
+    } else if (indexKeys.length >= softMaxRowsToRead) {
+      pageStatus = "SplitRecommended";
+      splitCursor = indexKeys[Math.floor((indexKeys.length - 1) / 2)];
+    }
+    return {
+      page,
+      isDone: !hasMore,
+      continueCursor,
+      pageStatus,
+      splitCursor: splitCursor ? serializeCursor(splitCursor) : void 0
+    };
+  }
+  async collect() {
+    return await this.take(Infinity);
+  }
+  async take(n) {
+    const results = [];
+    for await (const [doc2, _] of this.iterWithKeys()) {
+      if (doc2 === null) {
+        continue;
+      }
+      results.push(doc2);
+      if (results.length === n) {
+        break;
+      }
+    }
+    return results;
+  }
+  async unique() {
+    const docs = await this.take(2);
+    if (docs.length === 2) {
+      throw new Error("Query is not unique");
+    }
+    return docs[0] ?? null;
+  }
+  async first() {
+    const docs = await this.take(1);
+    return docs[0] ?? null;
+  }
+  [Symbol.asyncIterator]() {
+    const iterator = this.iterWithKeys()[Symbol.asyncIterator]();
+    return {
+      async next() {
+        const result = await iterator.next();
+        if (result.done) {
+          return { done: true, value: void 0 };
+        }
+        return { done: false, value: result.value[0] };
+      }
+    };
+  }
+}
+class StreamDatabaseReader {
+  db;
+  schema;
+  // TODO: support system tables
+  system;
+  constructor(db, schema) {
+    this.db = db;
+    this.schema = schema;
+    this.system = db.system;
+  }
+  query(tableName) {
+    return new StreamQueryInitializer(this, tableName);
+  }
+  get(_id) {
+    throw new Error("get() not supported for `paginator`");
+  }
+  normalizeId(_tableName, _id) {
+    throw new Error("normalizeId() not supported for `paginator`.");
+  }
+}
+class StreamableQuery extends QueryStream {
+}
+class StreamQueryInitializer extends StreamableQuery {
+  parent;
+  table;
+  constructor(parent, table) {
+    super();
+    this.parent = parent;
+    this.table = table;
+  }
+  fullTableScan() {
+    return this.withIndex("by_creation_time");
+  }
+  withIndex(indexName, indexRange) {
+    const indexFields = getIndexFields(this.table, indexName, this.parent.schema);
+    const q = new ReflectIndexRange(indexFields);
+    if (indexRange) {
+      indexRange(q);
+    }
+    return new StreamQuery(this, indexName, q, indexRange);
+  }
+  withSearchIndex(_indexName, _searchFilter) {
+    throw new Error("Cannot paginate withSearchIndex");
+  }
+  inner() {
+    return this.fullTableScan();
+  }
+  order(order) {
+    return this.inner().order(order);
+  }
+  reflect() {
+    return this.inner().reflect();
+  }
+  iterWithKeys() {
+    return this.inner().iterWithKeys();
+  }
+  getOrder() {
+    return this.inner().getOrder();
+  }
+  getEqualityIndexFilter() {
+    return this.inner().getEqualityIndexFilter();
+  }
+  getIndexFields() {
+    return this.inner().getIndexFields();
+  }
+  narrow(indexBounds) {
+    return this.inner().narrow(indexBounds);
+  }
+}
+class StreamQuery extends StreamableQuery {
+  parent;
+  index;
+  q;
+  indexRange;
+  constructor(parent, index, q, indexRange) {
+    super();
+    this.parent = parent;
+    this.index = index;
+    this.q = q;
+    this.indexRange = indexRange;
+  }
+  order(order) {
+    return new OrderedStreamQuery(this, order);
+  }
+  inner() {
+    return this.order("asc");
+  }
+  reflect() {
+    return this.inner().reflect();
+  }
+  iterWithKeys() {
+    return this.inner().iterWithKeys();
+  }
+  getOrder() {
+    return this.inner().getOrder();
+  }
+  getEqualityIndexFilter() {
+    return this.inner().getEqualityIndexFilter();
+  }
+  getIndexFields() {
+    return this.inner().getIndexFields();
+  }
+  narrow(indexBounds) {
+    return this.inner().narrow(indexBounds);
+  }
+}
+class OrderedStreamQuery extends StreamableQuery {
+  parent;
+  order;
+  constructor(parent, order) {
+    super();
+    this.parent = parent;
+    this.order = order;
+  }
+  reflect() {
+    return {
+      db: this.parent.parent.parent.db,
+      schema: this.parent.parent.parent.schema,
+      table: this.parent.parent.table,
+      index: this.parent.index,
+      indexFields: this.parent.q.indexFields,
+      order: this.order,
+      bounds: {
+        lowerBound: this.parent.q.lowerBoundIndexKey ?? [],
+        lowerBoundInclusive: this.parent.q.lowerBoundInclusive,
+        upperBound: this.parent.q.upperBoundIndexKey ?? [],
+        upperBoundInclusive: this.parent.q.upperBoundInclusive
+      },
+      indexRange: this.parent.indexRange
+    };
+  }
+  /**
+   * inner() is as if you had used ctx.db to construct the query.
+   */
+  inner() {
+    const { db, table, index, order, indexRange } = this.reflect();
+    return db.query(table).withIndex(index, indexRange).order(order);
+  }
+  iterWithKeys() {
+    const { indexFields } = this.reflect();
+    const iterable = this.inner();
+    return {
+      [Symbol.asyncIterator]() {
+        const iterator = iterable[Symbol.asyncIterator]();
+        return {
+          async next() {
+            const result = await iterator.next();
+            if (result.done) {
+              return { done: true, value: void 0 };
+            }
+            return {
+              done: false,
+              value: [result.value, getIndexKey(result.value, indexFields)]
+            };
+          }
+        };
+      }
+    };
+  }
+  getOrder() {
+    return this.order;
+  }
+  getEqualityIndexFilter() {
+    return this.parent.q.equalityIndexFilter;
+  }
+  getIndexFields() {
+    return this.parent.q.indexFields;
+  }
+  narrow(indexBounds) {
+    const { db, table, index, order, bounds, schema } = this.reflect();
+    let maxLowerBound = bounds.lowerBound;
+    let maxLowerBoundInclusive = bounds.lowerBoundInclusive;
+    if (compareKeys({
+      value: indexBounds.lowerBound,
+      kind: indexBounds.lowerBoundInclusive ? "predecessor" : "successor"
+    }, {
+      value: bounds.lowerBound,
+      kind: bounds.lowerBoundInclusive ? "predecessor" : "successor"
+    }) > 0) {
+      maxLowerBound = indexBounds.lowerBound;
+      maxLowerBoundInclusive = indexBounds.lowerBoundInclusive;
+    }
+    let minUpperBound = bounds.upperBound;
+    let minUpperBoundInclusive = bounds.upperBoundInclusive;
+    if (compareKeys({
+      value: indexBounds.upperBound,
+      kind: indexBounds.upperBoundInclusive ? "successor" : "predecessor"
+    }, {
+      value: bounds.upperBound,
+      kind: bounds.upperBoundInclusive ? "successor" : "predecessor"
+    }) < 0) {
+      minUpperBound = indexBounds.upperBound;
+      minUpperBoundInclusive = indexBounds.upperBoundInclusive;
+    }
+    return streamIndexRange(db, schema, table, index, {
+      lowerBound: maxLowerBound,
+      lowerBoundInclusive: maxLowerBoundInclusive,
+      upperBound: minUpperBound,
+      upperBoundInclusive: minUpperBoundInclusive
+    }, order);
+  }
+}
+function streamIndexRange(db, schema, table, index, bounds, order) {
+  const indexFields = getIndexFields(table, index, schema);
+  const splitBounds = splitRange(indexFields, order, bounds.lowerBound, bounds.upperBound, bounds.lowerBoundInclusive ? "gte" : "gt", bounds.upperBoundInclusive ? "lte" : "lt");
+  const subQueries = splitBounds.map((splitBound) => stream(db, schema).query(table).withIndex(index, rangeToQuery(splitBound)).order(order));
+  return new ConcatStreams(...subQueries);
+}
+class ReflectIndexRange {
+  indexFields;
+  #hasSuffix = false;
+  lowerBoundIndexKey = void 0;
+  lowerBoundInclusive = true;
+  upperBoundIndexKey = void 0;
+  upperBoundInclusive = true;
+  equalityIndexFilter = [];
+  constructor(indexFields) {
+    this.indexFields = indexFields;
+  }
+  eq(field, value) {
+    if (!this.#canLowerBound(field) || !this.#canUpperBound(field)) {
+      throw new Error(`Cannot use eq on field '${field}'`);
+    }
+    this.lowerBoundIndexKey = this.lowerBoundIndexKey ?? [];
+    this.lowerBoundIndexKey.push(value);
+    this.upperBoundIndexKey = this.upperBoundIndexKey ?? [];
+    this.upperBoundIndexKey.push(value);
+    this.equalityIndexFilter.push(value);
+    return this;
+  }
+  lt(field, value) {
+    if (!this.#canUpperBound(field)) {
+      throw new Error(`Cannot use lt on field '${field}'`);
+    }
+    this.upperBoundIndexKey = this.upperBoundIndexKey ?? [];
+    this.upperBoundIndexKey.push(value);
+    this.upperBoundInclusive = false;
+    this.#hasSuffix = true;
+    return this;
+  }
+  lte(field, value) {
+    if (!this.#canUpperBound(field)) {
+      throw new Error(`Cannot use lte on field '${field}'`);
+    }
+    this.upperBoundIndexKey = this.upperBoundIndexKey ?? [];
+    this.upperBoundIndexKey.push(value);
+    this.#hasSuffix = true;
+    return this;
+  }
+  gt(field, value) {
+    if (!this.#canLowerBound(field)) {
+      throw new Error(`Cannot use gt on field '${field}'`);
+    }
+    this.lowerBoundIndexKey = this.lowerBoundIndexKey ?? [];
+    this.lowerBoundIndexKey.push(value);
+    this.lowerBoundInclusive = false;
+    this.#hasSuffix = true;
+    return this;
+  }
+  gte(field, value) {
+    if (!this.#canLowerBound(field)) {
+      throw new Error(`Cannot use gte on field '${field}'`);
+    }
+    this.lowerBoundIndexKey = this.lowerBoundIndexKey ?? [];
+    this.lowerBoundIndexKey.push(value);
+    this.#hasSuffix = true;
+    return this;
+  }
+  #canLowerBound(field) {
+    const currentLowerBoundLength = this.lowerBoundIndexKey?.length ?? 0;
+    const currentUpperBoundLength = this.upperBoundIndexKey?.length ?? 0;
+    if (currentLowerBoundLength > currentUpperBoundLength) {
+      return false;
+    }
+    if (currentLowerBoundLength === currentUpperBoundLength && this.#hasSuffix) {
+      return false;
+    }
+    return currentLowerBoundLength < this.indexFields.length && this.indexFields[currentLowerBoundLength] === field;
+  }
+  #canUpperBound(field) {
+    const currentLowerBoundLength = this.lowerBoundIndexKey?.length ?? 0;
+    const currentUpperBoundLength = this.upperBoundIndexKey?.length ?? 0;
+    if (currentUpperBoundLength > currentLowerBoundLength) {
+      return false;
+    }
+    if (currentLowerBoundLength === currentUpperBoundLength && this.#hasSuffix) {
+      return false;
+    }
+    return currentUpperBoundLength < this.indexFields.length && this.indexFields[currentUpperBoundLength] === field;
+  }
+}
+function allSame(values, errorMessage) {
+  const first = values[0];
+  for (const value of values) {
+    if (compareValues(value, first)) {
+      throw new Error(errorMessage);
+    }
+  }
+  return first;
+}
+function commonPrefix(values) {
+  let commonPrefix2 = values[0];
+  for (const value of values) {
+    for (let i = 0; i < commonPrefix2.length; i++) {
+      if (i >= value.length || compareValues(commonPrefix2[i], value[i])) {
+        commonPrefix2 = commonPrefix2.slice(0, i);
+        break;
+      }
+    }
+  }
+  return commonPrefix2;
+}
+class ConcatStreams extends QueryStream {
+  #order;
+  #streams;
+  #equalityIndexFilter;
+  #indexFields;
+  constructor(...streams) {
+    super();
+    this.#streams = streams;
+    if (streams.length === 0) {
+      throw new Error("Cannot concat empty array of streams");
+    }
+    this.#order = allSame(streams.map((stream2) => stream2.getOrder()), "Cannot concat streams with different orders. Consider using .orderBy()");
+    this.#indexFields = allSame(streams.map((stream2) => stream2.getIndexFields()), "Cannot concat streams with different index fields. Consider using .orderBy()");
+    this.#equalityIndexFilter = commonPrefix(streams.map((stream2) => stream2.getEqualityIndexFilter()));
+  }
+  iterWithKeys() {
+    const iterables = this.#streams.map((stream2) => stream2.iterWithKeys());
+    const comparisonInversion = this.#order === "asc" ? 1 : -1;
+    let previousIndexKey = void 0;
+    return {
+      [Symbol.asyncIterator]() {
+        const iterators = iterables.map((iterable) => iterable[Symbol.asyncIterator]());
+        return {
+          async next() {
+            while (iterators.length > 0) {
+              const result = await iterators[0].next();
+              if (result.done) {
+                iterators.shift();
+              } else {
+                const [_, indexKey] = result.value;
+                if (previousIndexKey !== void 0 && compareKeys({
+                  value: previousIndexKey,
+                  kind: "exact"
+                }, {
+                  value: indexKey,
+                  kind: "exact"
+                }) * comparisonInversion > 0) {
+                  throw new Error(`ConcatStreams in wrong order: ${JSON.stringify(previousIndexKey)}, ${JSON.stringify(indexKey)}`);
+                }
+                previousIndexKey = indexKey;
+                return result;
+              }
+            }
+            return { done: true, value: void 0 };
+          }
+        };
+      }
+    };
+  }
+  getOrder() {
+    return this.#order;
+  }
+  getEqualityIndexFilter() {
+    return this.#equalityIndexFilter;
+  }
+  getIndexFields() {
+    return this.#indexFields;
+  }
+  narrow(indexBounds) {
+    return new ConcatStreams(...this.#streams.map((stream2) => stream2.narrow(indexBounds)));
+  }
+}
+class FlatMapStreamIterator {
+  #outerStream;
+  #outerIterator;
+  #currentOuterItem = null;
+  #mapper;
+  #mappedIndexFields;
+  constructor(outerStream, mapper, mappedIndexFields) {
+    this.#outerIterator = outerStream.iterWithKeys()[Symbol.asyncIterator]();
+    this.#outerStream = outerStream;
+    this.#mapper = mapper;
+    this.#mappedIndexFields = mappedIndexFields;
+  }
+  singletonSkipInnerStream() {
+    const indexKey = this.#mappedIndexFields.map(() => null);
+    return new SingletonStream(null, this.#outerStream.getOrder(), this.#mappedIndexFields, indexKey, indexKey);
+  }
+  async setCurrentOuterItem(item) {
+    const [t, indexKey] = item;
+    let innerStream;
+    if (t === null) {
+      innerStream = this.singletonSkipInnerStream();
+    } else {
+      innerStream = await this.#mapper(t);
+      if (!equalIndexFields(innerStream.getIndexFields(), this.#mappedIndexFields)) {
+        throw new Error(`FlatMapStream: inner stream has different index fields than expected: ${JSON.stringify(innerStream.getIndexFields())} vs ${JSON.stringify(this.#mappedIndexFields)}`);
+      }
+      if (innerStream.getOrder() !== this.#outerStream.getOrder()) {
+        throw new Error(`FlatMapStream: inner stream has different order than outer stream: ${innerStream.getOrder()} vs ${this.#outerStream.getOrder()}`);
+      }
+    }
+    this.#currentOuterItem = {
+      t,
+      indexKey,
+      innerIterator: innerStream.iterWithKeys()[Symbol.asyncIterator](),
+      count: 0
+    };
+  }
+  async next() {
+    if (this.#currentOuterItem === null) {
+      const result2 = await this.#outerIterator.next();
+      if (result2.done) {
+        return { done: true, value: void 0 };
+      }
+      await this.setCurrentOuterItem(result2.value);
+      return await this.next();
+    }
+    const result = await this.#currentOuterItem.innerIterator.next();
+    if (result.done) {
+      if (this.#currentOuterItem.count > 0) {
+        this.#currentOuterItem = null;
+      } else {
+        this.#currentOuterItem.innerIterator = this.singletonSkipInnerStream().iterWithKeys()[Symbol.asyncIterator]();
+      }
+      return await this.next();
+    }
+    const [u, indexKey] = result.value;
+    this.#currentOuterItem.count++;
+    const fullIndexKey = [...this.#currentOuterItem.indexKey, ...indexKey];
+    return { done: false, value: [u, fullIndexKey] };
+  }
+}
+class FlatMapStream extends QueryStream {
+  #stream;
+  #mapper;
+  #mappedIndexFields;
+  constructor(stream2, mapper, mappedIndexFields) {
+    super();
+    this.#stream = stream2;
+    this.#mapper = mapper;
+    this.#mappedIndexFields = mappedIndexFields;
+  }
+  iterWithKeys() {
+    const outerStream = this.#stream;
+    const mapper = this.#mapper;
+    const mappedIndexFields = this.#mappedIndexFields;
+    return {
+      [Symbol.asyncIterator]() {
+        return new FlatMapStreamIterator(outerStream, mapper, mappedIndexFields);
+      }
+    };
+  }
+  getOrder() {
+    return this.#stream.getOrder();
+  }
+  getEqualityIndexFilter() {
+    return this.#stream.getEqualityIndexFilter();
+  }
+  getIndexFields() {
+    return [...this.#stream.getIndexFields(), ...this.#mappedIndexFields];
+  }
+  narrow(indexBounds) {
+    const outerLength = this.#stream.getIndexFields().length;
+    const outerLowerBound = indexBounds.lowerBound.slice(0, outerLength);
+    const outerUpperBound = indexBounds.upperBound.slice(0, outerLength);
+    const innerLowerBound = indexBounds.lowerBound.slice(outerLength);
+    const innerUpperBound = indexBounds.upperBound.slice(outerLength);
+    const outerIndexBounds = {
+      lowerBound: outerLowerBound,
+      lowerBoundInclusive: innerLowerBound.length === 0 ? indexBounds.lowerBoundInclusive : true,
+      upperBound: outerUpperBound,
+      upperBoundInclusive: innerUpperBound.length === 0 ? indexBounds.upperBoundInclusive : true
+    };
+    const innerIndexBounds = {
+      lowerBound: innerLowerBound,
+      lowerBoundInclusive: innerLowerBound.length === 0 ? true : indexBounds.lowerBoundInclusive,
+      upperBound: innerUpperBound,
+      upperBoundInclusive: innerUpperBound.length === 0 ? true : indexBounds.upperBoundInclusive
+    };
+    return new FlatMapStream(this.#stream.narrow(outerIndexBounds), async (t) => {
+      const innerStream = await this.#mapper(t);
+      return innerStream.narrow(innerIndexBounds);
+    }, this.#mappedIndexFields);
+  }
+}
+class SingletonStream extends QueryStream {
+  #value;
+  #order;
+  #indexFields;
+  #indexKey;
+  #equalityIndexFilter;
+  constructor(value, order = "asc", indexFields, indexKey, equalityIndexFilter) {
+    super();
+    this.#value = value;
+    this.#order = order;
+    this.#indexFields = indexFields;
+    this.#indexKey = indexKey;
+    this.#equalityIndexFilter = equalityIndexFilter;
+    if (indexKey.length !== indexFields.length) {
+      throw new Error(`indexKey must have the same length as indexFields: ${JSON.stringify(indexKey)} vs ${JSON.stringify(indexFields)}`);
+    }
+  }
+  iterWithKeys() {
+    const value = this.#value;
+    const indexKey = this.#indexKey;
+    return {
+      [Symbol.asyncIterator]() {
+        let sent = false;
+        return {
+          async next() {
+            if (sent) {
+              return { done: true, value: void 0 };
+            }
+            sent = true;
+            return { done: false, value: [value, indexKey] };
+          }
+        };
+      }
+    };
+  }
+  getOrder() {
+    return this.#order;
+  }
+  getIndexFields() {
+    return this.#indexFields;
+  }
+  getEqualityIndexFilter() {
+    return this.#equalityIndexFilter;
+  }
+  narrow(indexBounds) {
+    const compareLowerBound = compareKeys({
+      value: indexBounds.lowerBound,
+      kind: indexBounds.lowerBoundInclusive ? "exact" : "successor"
+    }, {
+      value: this.#indexKey,
+      kind: "exact"
+    });
+    const compareUpperBound = compareKeys({
+      value: this.#indexKey,
+      kind: "exact"
+    }, {
+      value: indexBounds.upperBound,
+      kind: indexBounds.upperBoundInclusive ? "exact" : "predecessor"
+    });
+    if (compareLowerBound <= 0 && compareUpperBound <= 0) {
+      return new SingletonStream(this.#value, this.#order, this.#indexFields, this.#indexKey, this.#equalityIndexFilter);
+    }
+    return new EmptyStream(this.#order, this.#indexFields);
+  }
+}
+class EmptyStream extends QueryStream {
+  #order;
+  #indexFields;
+  constructor(order, indexFields) {
+    super();
+    this.#order = order;
+    this.#indexFields = indexFields;
+  }
+  iterWithKeys() {
+    return {
+      [Symbol.asyncIterator]() {
+        return {
+          async next() {
+            return { done: true, value: void 0 };
+          }
+        };
+      }
+    };
+  }
+  getOrder() {
+    return this.#order;
+  }
+  getIndexFields() {
+    return this.#indexFields;
+  }
+  getEqualityIndexFilter() {
+    return [];
+  }
+  narrow(_indexBounds) {
+    return this;
+  }
+}
+function normalizeIndexFields(indexFields) {
+  if (!indexFields.includes("_creationTime")) {
+    if (indexFields.length !== 1 || indexFields[0] !== "_id") {
+      indexFields.push("_creationTime");
+    }
+  }
+  if (!indexFields.includes("_id")) {
+    indexFields.push("_id");
+  }
+}
+function* getOrderingIndexFields(stream2) {
+  const streamEqualityIndexLength = stream2.getEqualityIndexFilter().length;
+  const streamIndexFields = stream2.getIndexFields();
+  for (let i = 0; i <= streamEqualityIndexLength; i++) {
+    yield streamIndexFields.slice(i);
+  }
+}
+class DistinctStream extends QueryStream {
+  #distinctIndexFieldsLength;
+  #stream;
+  #distinctIndexFields;
+  constructor(stream2, distinctIndexFields) {
+    super();
+    this.#stream = stream2;
+    this.#distinctIndexFields = distinctIndexFields;
+    let distinctIndexFieldsLength = void 0;
+    for (const orderingIndexFields of getOrderingIndexFields(stream2)) {
+      const prefix = orderingIndexFields.slice(0, distinctIndexFields.length);
+      if (equalIndexFields(prefix, distinctIndexFields)) {
+        const equalityLength = stream2.getIndexFields().length - orderingIndexFields.length;
+        distinctIndexFieldsLength = equalityLength + distinctIndexFields.length;
+        break;
+      }
+    }
+    if (distinctIndexFieldsLength === void 0) {
+      throw new Error(`distinctIndexFields must be a prefix of the stream's ordering index fields: ${JSON.stringify(distinctIndexFields)}, ${JSON.stringify(stream2.getIndexFields())} (${stream2.getEqualityIndexFilter().length} equality fields)`);
+    }
+    this.#distinctIndexFieldsLength = distinctIndexFieldsLength;
+  }
+  iterWithKeys() {
+    const stream2 = this.#stream;
+    const distinctIndexFieldsLength = this.#distinctIndexFieldsLength;
+    return {
+      [Symbol.asyncIterator]() {
+        let currentStream = stream2;
+        let currentIterator = currentStream.iterWithKeys()[Symbol.asyncIterator]();
+        return {
+          async next() {
+            const result = await currentIterator.next();
+            if (result.done) {
+              return { done: true, value: void 0 };
+            }
+            const [doc2, indexKey] = result.value;
+            if (doc2 === null) {
+              return { done: false, value: [null, indexKey] };
+            }
+            const distinctIndexKey = indexKey.slice(0, distinctIndexFieldsLength);
+            if (stream2.getOrder() === "asc") {
+              currentStream = currentStream.narrow({
+                lowerBound: distinctIndexKey,
+                lowerBoundInclusive: false,
+                upperBound: [],
+                upperBoundInclusive: true
+              });
+            } else {
+              currentStream = currentStream.narrow({
+                lowerBound: [],
+                lowerBoundInclusive: true,
+                upperBound: distinctIndexKey,
+                upperBoundInclusive: false
+              });
+            }
+            currentIterator = currentStream.iterWithKeys()[Symbol.asyncIterator]();
+            return result;
+          }
+        };
+      }
+    };
+  }
+  narrow(indexBounds) {
+    const indexBoundsPrefix = {
+      ...indexBounds,
+      lowerBound: indexBounds.lowerBound.slice(0, this.#distinctIndexFieldsLength),
+      upperBound: indexBounds.upperBound.slice(0, this.#distinctIndexFieldsLength)
+    };
+    return new DistinctStream(this.#stream.narrow(indexBoundsPrefix), this.#distinctIndexFields);
+  }
+  getOrder() {
+    return this.#stream.getOrder();
+  }
+  getIndexFields() {
+    return this.#stream.getIndexFields();
+  }
+  getEqualityIndexFilter() {
+    return this.#stream.getEqualityIndexFilter();
+  }
+}
+function equalIndexFields(indexFields1, indexFields2) {
+  if (indexFields1.length !== indexFields2.length) {
+    return false;
+  }
+  for (let i = 0; i < indexFields1.length; i++) {
+    if (indexFields1[i] !== indexFields2[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function getValueAtIndex(v2, index) {
+  if (index >= v2.length) {
+    return void 0;
+  }
+  return { kind: "found", value: v2[index] };
+}
+function compareDanglingSuffix(shorterKeyKind, longerKeyKind, shorterKey, longerKey) {
+  if (shorterKeyKind === "exact" && longerKeyKind === "exact") {
+    throw new Error(`Exact keys are not the same length:  ${JSON.stringify(shorterKey.value)}, ${JSON.stringify(longerKey.value)}`);
+  }
+  if (shorterKeyKind === "exact") {
+    throw new Error(`Exact key is shorter than prefix: ${JSON.stringify(shorterKey.value)}, ${JSON.stringify(longerKey.value)}`);
+  }
+  if (shorterKeyKind === "predecessor" && longerKeyKind === "successor") {
+    return -1;
+  }
+  if (shorterKeyKind === "successor" && longerKeyKind === "predecessor") {
+    return 1;
+  }
+  if (shorterKeyKind === "predecessor" && longerKeyKind === "predecessor") {
+    return -1;
+  }
+  if (shorterKeyKind === "successor" && longerKeyKind === "successor") {
+    return 1;
+  }
+  if (shorterKeyKind === "predecessor" && longerKeyKind === "exact") {
+    return -1;
+  }
+  if (shorterKeyKind === "successor" && longerKeyKind === "exact") {
+    return 1;
+  }
+  throw new Error(`Unexpected key kinds: ${shorterKeyKind}, ${longerKeyKind}`);
+}
+function compareKeys(key1, key2) {
+  let i = 0;
+  while (i < Math.max(key1.value.length, key2.value.length)) {
+    const v1 = getValueAtIndex(key1.value, i);
+    const v2 = getValueAtIndex(key2.value, i);
+    if (v1 === void 0) {
+      return compareDanglingSuffix(key1.kind, key2.kind, key1, key2);
+    }
+    if (v2 === void 0) {
+      return -1 * compareDanglingSuffix(key2.kind, key1.kind, key2, key1);
+    }
+    const result = compareValues(v1.value, v2.value);
+    if (result !== 0) {
+      return result;
+    }
+    i++;
+  }
+  if (key1.kind === key2.kind) {
+    return 0;
+  }
+  if (key1.kind === "exact") {
+    if (key2.kind === "successor") {
+      return -1;
+    } else {
+      return 1;
+    }
+  }
+  if (key1.kind === "predecessor") {
+    return -1;
+  }
+  if (key1.kind === "successor") {
+    return 1;
+  }
+  throw new Error(`Unexpected key kind: ${key1.kind}`);
+}
+function serializeCursor(key) {
+  return JSON.stringify(convexToJson(key.map((v2) => v2 === void 0 ? "undefined" : typeof v2 === "string" && v2.endsWith("undefined") ? (
+    // in the unlikely case their string was "undefined"
+    // or "_undefined" etc, we escape it.
+    "_" + v2
+  ) : v2)));
+}
+function deserializeCursor(cursor) {
+  return jsonToConvex(JSON.parse(cursor)).map((v2) => {
+    if (typeof v2 === "string") {
+      if (v2 === "undefined") {
+        return void 0;
+      }
+      if (v2.endsWith("undefined")) {
+        return v2.slice(1);
+      }
+    }
+    return v2;
+  });
+}
 export {
   doc as d,
-  omit as o
+  omit as o,
+  stream as s
 };