@toa.io/storages.mongodb 1.0.0-alpha.317 → 1.0.0-alpha.319

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [1.0.0-alpha.319](https://github.com/toa-io/toa/compare/v1.0.0-alpha.318...v1.0.0-alpha.319) (2026-09-27)
+
+### Features
+
+* **storages.mongodb:** read a set and its changes from a token ([d0a8955](https://github.com/toa-io/toa/commit/d0a8955683b7566e704f7e9cde69f67272c7be1b))
+
+
+# [1.0.0-alpha.318](https://github.com/toa-io/toa/compare/v1.0.0-alpha.317...v1.0.0-alpha.318) (2026-09-23)
+
+**Note:** Version bump only for package @toa.io/storages.mongodb
+
+
+
+
+
 # [1.0.0-alpha.317](https://github.com/toa-io/toa/compare/v1.0.0-alpha.316...v1.0.0-alpha.317) (2026-09-23)
 
 **Note:** Version bump only for package @toa.io/storages.mongodb

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toa.io/storages.mongodb",
-  "version": "1.0.0-alpha.317",
+  "version": "1.0.0-alpha.319",
   "type": "module",
   "description": "Toa MongoDB Storage Connector",
   "author": "temich <tema.gurtovoy@gmail.com>",
@@ -21,12 +21,12 @@
   },
   "dependencies": {
     "@toa.io/conveyor": "1.0.0-alpha.311",
-    "@toa.io/core": "1.0.0-alpha.315",
-    "@toa.io/definitions": "1.0.0-alpha.317",
+    "@toa.io/core": "1.0.0-alpha.319",
+    "@toa.io/definitions": "1.0.0-alpha.319",
     "@toa.io/generic": "1.0.0-alpha.311",
     "@toa.io/pointer": "1.0.0-alpha.311",
     "mongodb": "7.6.0",
     "openspan": "1.0.0-alpha.305"
   },
-  "gitHead": "a88d6124557d4e2819402ae8a0b891fb3dee479c"
+  "gitHead": "ee4901f2bc12c33fc2098a62f2af0c29838a2c2c"
 }

package/readme.md

@@ -13,3 +13,23 @@ and internal driver commands (`hello`, `ping`, authentication) are not recorded.
 
 Monitoring is client-side only and does not affect the MongoDB server. Span recording
 adds no waiting to the query path: exporting is buffered and happens in the background.
+
+## Stream tokens
+
+A [stream](/documentation/collections.md) ends with a token of changes where two things hold:
+
+- **MongoDB runs as a replica set**, which it does wherever there is an outbox.
+- **The collection keeps images** of what a record was before each change, which is how a change
+  that takes an entry out of the collection is told from a change outside it. They cost a copy of every
+  changed record for as long as the oplog holds it, so a collection keeps them only by a
+  [migration](/documentation/component/declaration.md#migrations):
+
+  ```yaml
+  # migrations/0003-images.yaml
+  - images: true
+  ```
+
+  `- images: false` stops keeping them, and a token issued before is then refused with `410`.
+
+A token lasts as long as the oplog of the replica set holds the point it names — its window, which
+the size of the oplog and the rate of writes decide.

package/src/match.js

@@ -0,0 +1,103 @@
+/**
+ * Whether a record matches a filter `translate` wrote, as MongoDB would decide it. A change
+ * stream says a record changed, and whether a reader is to add it or drop it is whether its
+ * image after the change matches the reader's criteria, or only its image before.
+ *
+ * What `translate` writes is all there is to decide: `$and`, `$or`, and a field compared with
+ * `$eq`, `$ne`, `$gt`, `$gte`, `$lt`, `$lte`, `$in`, `$nin` or a bare value. A search is not a
+ * filter on a record, and is refused.
+ *
+ * @param {object} record
+ * @param {object} filter
+ * @returns {boolean}
+ */
+export function match(record, filter) {
+  for (const [key, condition] of Object.entries(filter))
+    if (!matches(record, key, condition)) return false
+
+  return true
+}
+
+function matches(record, key, condition) {
+  switch (key) {
+    case '$and':
+      return condition.every((filter) => match(record, filter))
+    case '$or':
+      return condition.some((filter) => match(record, filter))
+    case '$nor':
+      return !condition.some((filter) => match(record, filter))
+    default:
+      if (key.startsWith('$')) throw new Error(`A change cannot be matched against '${key}'`)
+
+      return field(read(record, key), condition)
+  }
+}
+
+function field(value, condition) {
+  if (!operators(condition)) return OPERATORS.$eq(value, condition)
+
+  for (const [operator, operand] of Object.entries(condition)) {
+    const test = OPERATORS[operator]
+
+    if (test === undefined) throw new Error(`A change cannot be matched against '${operator}'`)
+    if (!test(value, operand)) return false
+  }
+
+  return true
+}
+
+const OPERATORS = {
+  $eq: (value, operand) => some(value, (v) => equal(v, operand)),
+  $ne: (value, operand) => !OPERATORS.$eq(value, operand),
+  $in: (value, operands) => operands.some((operand) => OPERATORS.$eq(value, operand)),
+  $nin: (value, operands) => !OPERATORS.$in(value, operands),
+  $gt: (value, operand) => some(value, (v) => compare(v, operand) > 0),
+  $gte: (value, operand) => some(value, (v) => compare(v, operand) >= 0),
+  $lt: (value, operand) => some(value, (v) => compare(v, operand) < 0),
+  $lte: (value, operand) => some(value, (v) => compare(v, operand) <= 0)
+}
+
+/** An array matches where the array or one of its elements does, as MongoDB has it. */
+function some(value, test) {
+  return test(value) || (Array.isArray(value) && value.some(test))
+}
+
+/** `null` is equal to a field that is not there, and a date to a date of the same instant. */
+function equal(value, operand) {
+  if (operand === null) return value === null || value === undefined
+  if (operand instanceof Date) return value instanceof Date && value.getTime() === operand.getTime()
+
+  return value === operand
+}
+
+/** Values of one type compare, and values of two types are neither greater nor less. */
+function compare(value, operand) {
+  if (value instanceof Date && operand instanceof Date) return value.getTime() - operand.getTime()
+  if (typeof value === 'number' && typeof operand === 'number') return value - operand
+
+  if (typeof value === 'string' && typeof operand === 'string')
+    return value < operand ? -1 : value > operand ? 1 : 0
+
+  return NaN
+}
+
+function operators(condition) {
+  if (condition === null || typeof condition !== 'object' || condition instanceof Date) return false
+  if (Array.isArray(condition)) return false
+
+  const keys = Object.keys(condition)
+
+  return keys.length > 0 && keys.every((key) => key.startsWith('$'))
+}
+
+function read(record, path) {
+  let value = record
+
+  for (const key of path.split('.')) {
+    if (value === null || typeof value !== 'object') return undefined
+
+    value = value[key]
+  }
+
+  return value
+}

package/src/migrations.js

@@ -301,7 +301,21 @@ async function remove(collection, { filter }, id) {
   })
 }
 
-const STEPS = { index, dropIndex, update, delete: remove }
+/**
+ * Keeps, or stops keeping, what a record was before each change and after it, which a stream
+ * reads to tell an entry that left a set from a change outside it.
+ */
+async function images(collection, enabled, id) {
+  if (typeof enabled !== 'boolean')
+    throw new Error(`Migration '${id}' declares images that are neither true nor false`)
+
+  await collection.s.db.command({
+    collMod: collection.collectionName,
+    changeStreamPreAndPostImages: { enabled }
+  })
+}
+
+const STEPS = { index, dropIndex, update, delete: remove, images }
 
 const DIRECTIONS = { asc: 1, desc: -1, hash: 'hashed' }
 

package/src/storage.js

@@ -5,6 +5,7 @@ import { codec } from './record.js'
 import { Inbox } from './inbox.js'
 import { Outbox } from './outbox.js'
 import { Migrations } from './migrations.js'
+import { Streams } from './streams.js'
 import { conflicted, query } from './measurements.js'
 import { ReturnDocument } from 'mongodb'
 
@@ -34,6 +35,9 @@ export class Storage extends Connector {
   /** @type {Map<string, object>} span options per driver method */
   #spans = new Map()
 
+  /** @type {Streams | undefined} what a stream reads, and where it continues from */
+  #streams
+
   /** how a record is written and read back, which depends on what the entity declares */
   #to
   #from
@@ -108,6 +112,22 @@ export class Storage extends Connector {
 
     await this.#outbox?.index()
     await this.#inbox?.index()
+
+    this.#streams = new Streams(
+      this.#collection,
+      () => this.#client.instance.client,
+      this.#from,
+      this.#client.transactional === true && (await this.#images())
+    )
+  }
+
+  /** Whether the collection keeps what a record was before a change, which a migration says. */
+  async #images() {
+    const collection = await this.#client.db
+      .listCollections({ name: this.#collection.collectionName })
+      .next()
+
+    return collection?.options?.changeStreamPreAndPostImages?.enabled === true
   }
 
   async get(query) {
@@ -160,7 +180,7 @@ export class Storage extends Connector {
 
     this.debug('find (stream)', { criteria, options })
 
-    return this.#collection.find(criteria, options).stream({ transform: this.#from })
+    return this.#streams.stream({ criteria, options }, query?.options?.token)
   }
 
   async add(entity, session = undefined) {

package/src/streams.js

@@ -0,0 +1,317 @@
+import { createHash } from 'node:crypto'
+import { Readable } from 'node:stream'
+import { Timestamp } from 'mongodb'
+import { exceptions, parts } from '@toa.io/core'
+import { match } from './match.js'
+
+/**
+ * A collection read as a stream, and what changed in it since a token.
+ *
+ * A token is a position in the history MongoDB keeps of the writes committed to the collection —
+ * a change stream's resume token — so what it continues from is the order writes committed in.
+ * A first read takes the position before it reads anything: what committed before it is in what
+ * the read finds, and what committed after it is in the next read. A page is read after the last
+ * `_id` of the one before it, ordered by `_id`, which never changes, so an entry stays on one side
+ * of a page boundary for the whole read.
+ *
+ * Where MongoDB keeps no such history — a standalone server, or a collection that keeps no images
+ * of a record before a change — pages are still read, and a complete read ends with a `null`
+ * token: there is nothing to continue from.
+ */
+export class Streams {
+  /** @type {import('mongodb').Collection} */
+  #collection
+
+  /** @type {() => import('mongodb').MongoClient} the client sessions are started on */
+  #client
+
+  /** @type {(record: object) => object} */
+  #from
+
+  /** whether a position can be taken and read from */
+  #history
+
+  constructor(collection, client, from, history) {
+    this.#collection = collection
+    this.#client = client
+    this.#from = from
+    this.#history = history
+  }
+
+  /**
+   * @param {{ criteria: object, options: object }} translated
+   * @param {string} [given] the token the read continues from
+   * @returns {Promise<Readable>}
+   */
+  async stream(translated, given) {
+    const { criteria, options } = translated
+    const hash = digest(criteria)
+
+    if (given === undefined) return await this.#first(criteria, options, hash)
+
+    const token = decode(given)
+
+    if (token.h !== hash)
+      throw new exceptions.QuerySyntaxException('The token was issued for other criteria')
+
+    if (token.id !== undefined) return await this.#page(criteria, options, hash, token)
+    if (token.p === null || !this.#history) throw lost()
+
+    return await this.#changes(criteria, options, hash, token)
+  }
+
+  async #first(criteria, options, hash) {
+    const session = this.#client().startSession({ causalConsistency: true })
+
+    try {
+      const position = this.#history ? await this.#position(session) : null
+
+      return await this.#read(criteria, options, hash, session, position, undefined)
+    } catch (exception) {
+      await session.endSession()
+
+      throw exception
+    }
+  }
+
+  async #page(criteria, options, hash, token) {
+    if (token.p !== null && !this.#history) throw lost()
+
+    const session = this.#client().startSession({ causalConsistency: true })
+
+    if (token.t !== null) session.advanceOperationTime(new Timestamp(BigInt(token.t)))
+
+    const position = token.p === null ? null : { p: token.p, t: token.t }
+
+    try {
+      return await this.#read(criteria, options, hash, session, position, token.id)
+    } catch (exception) {
+      await session.endSession()
+
+      throw exception
+    }
+  }
+
+  /**
+   * The position: the resume token of a change stream opened with a batch of none. Its
+   * operation time is where a page is read at, so that a member of the replica set behind it
+   * waits until it has replicated it.
+   */
+  async #position(session) {
+    const db = this.#collection.s.db
+    const name = this.#collection.collectionName
+
+    const reply = await db.command(
+      { aggregate: name, pipeline: [{ $changeStream: {} }], cursor: { batchSize: 0 } },
+      { session }
+    )
+
+    const { id, postBatchResumeToken } = reply.cursor
+
+    if (!id.isZero()) await db.command({ killCursors: name, cursors: [id] }, { session })
+
+    return { p: postBatchResumeToken._data, t: session.operationTime.toString() }
+  }
+
+  /**
+   * The collection, or a page of it. A read that pages is ordered by `_id` and continues after the
+   * last one; one that does not is read in the order the query states.
+   */
+  async #read(criteria, options, hash, session, position, after) {
+    const limit = options.limit
+    const filter = after === undefined ? criteria : { $and: [criteria, { _id: { $gt: after } }] }
+
+    const read = { ...options, session, readConcern: { level: 'majority' } }
+
+    if (limit !== undefined) read.sort = { _id: 1 }
+
+    const cursor = this.#collection.find(filter, read)
+
+    // what refuses the read refuses it before a part is sent, where it is still an answer
+    await cursor.hasNext()
+
+    const from = this.#from
+
+    async function* yielding() {
+      let count = 0
+      let last
+
+      try {
+        for await (const record of cursor) {
+          count++
+          last = record._id
+
+          yield parts.entry(from(record))
+        }
+
+        if (limit !== undefined && count === limit)
+          yield parts.token(encode({ v: VERSION, p: position?.p ?? null, t: position?.t ?? null, id: last, h: hash }))
+        else yield parts.token(position === null ? null : encode({ v: VERSION, p: position.p, h: hash }))
+      } finally {
+        await cursor.close()
+        await session.endSession()
+      }
+    }
+
+    return Readable.from(yielding())
+  }
+
+  /**
+   * What committed after the token that concerns the collection: a change whose image after it matches
+   * the criteria is an entry, and one whose image before it alone does is a removal. A change
+   * that concerns neither is left out by the pipeline, so a reader learns no id it cannot read.
+   */
+  async #changes(criteria, options, hash, token) {
+    const pipeline = [
+      {
+        $match: {
+          $or: [
+            prefix(criteria, 'fullDocument.'),
+            prefix(criteria, 'fullDocumentBeforeChange.'),
+            { operationType: { $in: ENDINGS } }
+          ]
+        }
+      }
+    ]
+
+    const stream = this.#collection.watch(pipeline, {
+      startAfter: { _data: token.p },
+      fullDocument: 'required',
+      fullDocumentBeforeChange: 'required'
+    })
+
+    const limit = options.limit
+
+    let first
+
+    try {
+      first = await stream.tryNext()
+    } catch (exception) {
+      await stream.close()
+
+      throw refusal(exception)
+    }
+
+    const from = this.#from
+
+    async function* yielding() {
+      let count = 0
+      let event = first
+
+      try {
+        while (event !== null) {
+          if (ENDINGS.includes(event.operationType)) throw lost()
+
+          const part = classify(event, criteria, from)
+
+          if (part !== undefined) {
+            count++
+
+            yield part
+          }
+
+          if (limit !== undefined && count >= limit) break
+
+          event = await stream.tryNext().catch((exception) => {
+            throw refusal(exception)
+          })
+        }
+
+        yield parts.token(encode({ v: VERSION, p: stream.resumeToken._data, h: hash }))
+      } finally {
+        await stream.close()
+      }
+    }
+
+    return Readable.from(yielding())
+  }
+}
+
+function classify(event, criteria, from) {
+  const after = event.fullDocument
+  const before = event.fullDocumentBeforeChange
+
+  if (after !== undefined && after !== null && match(after, criteria)) return parts.entry(from(after))
+
+  if (before !== undefined && before !== null && match(before, criteria))
+    return parts.removed(String(event.documentKey._id))
+
+  return undefined
+}
+
+/**
+ * The criteria against an image of a change stream event. A key that is an operator carries
+ * filters, and every other key is a field of the record.
+ */
+function prefix(filter, path) {
+  const result = {}
+
+  for (const [key, value] of Object.entries(filter))
+    if (LOGICAL.includes(key)) result[key] = value.map((filter) => prefix(filter, path))
+    else if (key.startsWith('$'))
+      throw new exceptions.QuerySyntaxException(`What changed in a collection cannot be read by '${key}'`)
+    else result[path + key] = value
+
+  return result
+}
+
+function refusal(exception) {
+  if (LOST.includes(exception?.code) || exception?.hasErrorLabel?.('NonResumableChangeStreamError'))
+    return lost()
+
+  return exception
+}
+
+function lost() {
+  return new exceptions.StateHistoryException('The token names a point the storage no longer holds')
+}
+
+/**
+ * The criteria a token was issued for: a read that continues from it under other criteria would
+ * answer the changes to one collection as if they were those of another.
+ */
+function digest(criteria) {
+  return createHash('sha1').update(JSON.stringify(criteria)).digest('base64url').slice(0, 16)
+}
+
+function encode(token) {
+  return Buffer.from(JSON.stringify(token)).toString('base64url')
+}
+
+/** A token this storage did not write, or wrote in another format, names nothing it holds. */
+function decode(given) {
+  let token
+
+  try {
+    token = JSON.parse(Buffer.from(given, 'base64url').toString())
+  } catch {
+    throw lost()
+  }
+
+  const valid =
+    token !== null &&
+    typeof token === 'object' &&
+    token.v === VERSION &&
+    typeof token.h === 'string' &&
+    (typeof token.p === 'string' || token.p === null) &&
+    (token.id === undefined || typeof token.id === 'string') &&
+    (token.id === undefined || token.t === null || typeof token.t === 'string')
+
+  if (!valid) throw lost()
+
+  return token
+}
+
+/** the format of a token, which a storage that reads another refuses */
+const VERSION = 1
+
+const LOGICAL = ['$and', '$or', '$nor']
+
+/** what ends a change stream: the collection it follows is gone or renamed */
+const ENDINGS = ['drop', 'rename', 'dropDatabase', 'invalidate']
+
+/**
+ * ChangeStreamHistoryLost, ChangeStreamFatalError (a resume token that is not in the oplog), and
+ * NoMatchingDocument (an image that has expired).
+ */
+const LOST = [286, 280, 47]

package/test/match.test.js

@@ -0,0 +1,67 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { match } from '../src/match.js'
+
+const record = {
+  _id: 'a1',
+  owner: 'alice',
+  rank: 5,
+  tags: ['red', 'green'],
+  DELETED: null,
+  CREATED: new Date(1000)
+}
+
+describe('match', () => {
+  it('should match a bare value as equality', () => {
+    assert.equal(match(record, { owner: 'alice' }), true)
+    assert.equal(match(record, { owner: 'bob' }), false)
+  })
+
+  it('should match null against a field that is null or not there', () => {
+    assert.equal(match(record, { DELETED: null }), true)
+    assert.equal(match(record, { missing: null }), true)
+    assert.equal(match({ ...record, DELETED: new Date(1) }, { DELETED: null }), false)
+  })
+
+  it('should compare values of one type', () => {
+    assert.equal(match(record, { rank: { $gt: 4 } }), true)
+    assert.equal(match(record, { rank: { $gte: 5, $lt: 6 } }), true)
+    assert.equal(match(record, { rank: { $lte: 4 } }), false)
+    assert.equal(match(record, { owner: { $gt: 'a' } }), true)
+  })
+
+  it('should compare values of two types as neither greater nor less', () => {
+    assert.equal(match(record, { rank: { $gt: '1' } }), false)
+    assert.equal(match(record, { rank: { $lt: '9' } }), false)
+  })
+
+  it('should compare dates by their instant', () => {
+    assert.equal(match(record, { CREATED: new Date(1000) }), true)
+    assert.equal(match(record, { CREATED: { $gt: new Date(999) } }), true)
+    assert.equal(match(record, { CREATED: { $eq: new Date(1001) } }), false)
+  })
+
+  it('should match a list of values', () => {
+    assert.equal(match(record, { owner: { $in: ['bob', 'alice'] } }), true)
+    assert.equal(match(record, { owner: { $nin: ['bob', 'alice'] } }), false)
+    assert.equal(match(record, { owner: { $ne: 'bob' } }), true)
+  })
+
+  it('should match an array where one of its elements does', () => {
+    assert.equal(match(record, { tags: 'red' }), true)
+    assert.equal(match(record, { tags: { $in: ['blue', 'green'] } }), true)
+    assert.equal(match(record, { tags: { $ne: 'red' } }), false)
+  })
+
+  it('should combine filters', () => {
+    assert.equal(match(record, { $and: [{ owner: 'alice' }, { rank: { $gt: 1 } }] }), true)
+    assert.equal(match(record, { $or: [{ owner: 'bob' }, { rank: { $gt: 1 } }] }), true)
+    assert.equal(match(record, { $or: [{ owner: 'bob' }, { rank: { $gt: 9 } }] }), false)
+    assert.equal(match(record, { owner: 'alice', DELETED: null, _id: 'a1' }), true)
+  })
+
+  it('should refuse a search', () => {
+    assert.throws(() => match(record, { $text: { $search: 'x' } }))
+  })
+})

package/test/storage.test.js

@@ -12,20 +12,30 @@ beforeEach(async () => {
   collection = {
     collectionName: 'test',
     findOne: mock.fn(async () => null),
-    find: mock.fn(() => ({ stream: () => null })),
+    find: mock.fn(() => cursor()),
     updateMany: mock.fn(async () => ({ modifiedCount: 0 })),
     updateOne: mock.fn(async () => ({ upsertedCount: 0, modifiedCount: 0 }))
   }
 
   db = { collection: mock.fn(() => null) }
 
-  const client = { collection, db, link: () => null }
+  const session = { endSession: async () => undefined }
+  const instance = { client: { startSession: () => session } }
+  const client = { collection, db, instance, link: () => null }
 
   storage = new Storage(client, { schema: { properties: {} } })
 
   await storage.open()
 })
 
+function cursor() {
+  return {
+    hasNext: async () => false,
+    close: async () => undefined,
+    async *[Symbol.asyncIterator]() {}
+  }
+}
+
 describe('open', () => {
   it('should not touch the migrations record where the entity declares none', () => {
     assert.equal(db.collection.mock.callCount(), 0)
@@ -89,43 +99,45 @@ describe('get', () => {
 })
 
 describe('stream', () => {
+  const read = () => collection.find.mock.calls[0].arguments
+
   it('should filter deleted', async () => {
     await storage.stream()
 
-    assert.ok(
-      collection.find.mock.calls.some(
-        (call) =>
-          call.arguments.length === 2 &&
-          isDeepStrictEqual(call.arguments[0], { DELETED: null }) &&
-          isDeepStrictEqual(call.arguments[1], {})
-      )
-    )
+    assert.deepStrictEqual(read()[0], { DELETED: null })
   })
 
   it('should filter deleted with sort', async () => {
     await storage.stream({ options: { sort: [['CREATED', 'desc']] } })
 
-    assert.ok(
-      collection.find.mock.calls.some(
-        (call) =>
-          call.arguments.length === 2 &&
-          isDeepStrictEqual(call.arguments[0], { DELETED: null }) &&
-          isDeepStrictEqual(call.arguments[1], { sort: [['CREATED', -1]] })
-      )
-    )
+    assert.deepStrictEqual(read()[0], { DELETED: null })
+    assert.deepStrictEqual(read()[1].sort, [['CREATED', -1]])
   })
 
   it('should not filter deleted if requested', async () => {
     await storage.stream({ options: { deleted: true } })
 
-    assert.ok(
-      collection.find.mock.calls.some(
-        (call) =>
-          call.arguments.length === 2 &&
-          isDeepStrictEqual(call.arguments[0], {}) &&
-          isDeepStrictEqual(call.arguments[1], {})
-      )
-    )
+    assert.deepStrictEqual(read()[0], {})
+  })
+
+  it('should read what the majority of the replica set holds', async () => {
+    await storage.stream()
+
+    assert.deepStrictEqual(read()[1].readConcern, { level: 'majority' })
+  })
+
+  it('should end the set with no position where the storage keeps no history', async () => {
+    const stream = await storage.stream()
+    const parts = await stream.toArray()
+
+    assert.deepStrictEqual(parts, [{ token: null }])
+  })
+
+  it('should read a page ordered by id', async () => {
+    await storage.stream({ options: { limit: 2 } })
+
+    assert.deepStrictEqual(read()[1].sort, { _id: 1 })
+    assert.equal(read()[1].limit, 2)
   })
 })