anchordb-angular 1.3.3 → 1.4.1

package/CHANGELOG.md

@@ -0,0 +1,479 @@
+# Changelog
+
+All notable changes to the `anchordb` packages.
+
+This project follows [semantic versioning](https://semver.org/). While the version is `0.x`, minor
+releases may contain breaking changes.
+
+## 1.4.1
+
+**Security: `anchordb-sync-server` now keeps users apart.** Up to 1.4.0 the server checked the
+identity `authenticate` returned and then dropped it: every user pulled every user's documents and
+could change or delete any of them by id. Every version before 1.4.1 is affected. Found by the
+expense-tracker team.
+
+### Fixed
+
+- **Each document belongs to a scope**, `user:<id>` for the user who created it, and a user reads and
+  changes only their own. `authenticate` may return a user id, as before, or
+  `{ userId, scopes }` to give a user further scopes (shared books, from 1.5.0).
+- **Refusals reveal nothing.** Someone else's document is answered exactly as one that does not
+  exist: `rejected` with `code: 404`.
+- **Retry answers and unique checks are per user.** Remembered answers are keyed by user as well as
+  `clientId`, so one user can't read back another's. Unique indexes are checked within the user's
+  documents; `{ global: true }` on a unique index checks across everyone (for usernames, say).
+- **Fails closed.** Calling `handlePush`/`handlePull` yourself on a server with `authenticate` and no
+  caller is refused with 401. The Express, Next.js and NestJS adapters pass the caller for you.
+- **A server with no `authenticate` warns at startup**, since every caller then shares every
+  document. Pass `singleUser: true` if that is what you want; it becomes required in 1.5.0.
+
+### New
+
+- **`adoptUnscoped(options, { assignScope })`.** Documents written before 1.4.1 have no scope, and a
+  server with `authenticate` hides them from everyone until this one-time command assigns them, for
+  example `assignScope: (collection, doc) => doc.userId ? "user:" + doc.userId : null`. Each one it
+  assigns is sent to its owner's phones again. It is safe to run twice, and two processes running it
+  at once don't assign anything twice. A server that only one person used can assign everything to
+  that person: `() => "user:<their id>"`.
+- **Epoch.** Every response carries an `epoch` (default `"2"` with `authenticate`; set `epoch` to
+  change it). When a phone sees a new one, it deletes its synced copy and pulls again, keeping its
+  unsent changes (`sync:reset` event). That clears out other users' documents that phones pulled from
+  1.4.0 servers.
+- **Protocol version 2.** A server with `authenticate` answers phones built with an older anchordb
+  `426 Update the app`, since they ignore the epoch. `legacyClients: "allow"` serves them for a
+  transition period. They are still kept apart, but they keep whatever they already pulled.
+- **Pull limit** capped at 1000 changes (`maxPullLimit`).
+- **Each pulled change carries its `scope`**, and the phone records it with the document.
+
+### Changed on the phone (`anchordb`)
+
+- A change refused with 404 is parked, as before, and the phone now also deletes its copy of that
+  document — so another user's document that was edited offline doesn't stay on the phone. A
+  refused insert keeps the user's new document.
+- **A document deleted on the user's other phone** now comes back as a conflict marked
+  `deleted: true` with `document: null`, and goes through the conflict strategy: `server-wins`
+  accepts the delete; `last-write-wins` keeps a newer local edit and brings the document back;
+  `client-wins` always brings it back; `field-level` falls back to last-write-wins. A custom
+  `resolver` receives `remote: null`, and returns null to accept the delete. The `conflict` event
+  gains `remoteDeleted` and `resolvedDeleted`.
+
+### Upgrading — in this order
+
+1. **Upgrade the server** to `anchordb-sync-server@1.4.1`.
+2. **Run `adoptUnscoped`** once with an `assignScope` that knows whose each document is. Until you
+   do, those documents are hidden from everyone. Nothing is ever deleted on the server.
+3. **Ship a new app build** with `anchordb@1.4.1`. On its first sync it starts over once, because of
+   the new epoch, and its unsent changes are kept.
+
+App builds that use an anchordb version before 1.4.1 **stop syncing** (426) until users install the
+update, unless the server sets `legacyClients: "allow"`. A server without `authenticate` is unchanged:
+it still serves everyone everything, and still accepts old phones.
+
+## 1.4.0
+
+**Transactions, migrations, recovery, TTL indexes, encryption, a test kit — and guides that ship in the
+package.** Asked for by the expense-tracker team after building an offline-first app on 1.3; every
+item has tests, and nothing existing changes behaviour except as noted.
+
+### New
+
+- **`db.transaction(async (session) => …)`** — writes across collections, all or nothing, with
+  Mongoose's API: `{ session }` on `create`, `insertOne/Many`, `update*`, `replaceOne`, `delete*`,
+  `findOneAnd*`, `bulkWrite`, `aggregate`, the index methods and `doc.save()`, and `.session()` on
+  queries. A throw rolls every collection back; `change` events and queued sync mutations wait for
+  the commit. A call inside made without the session times out the transaction with
+  `TransactionTimeoutError` (`transactionTimeoutMs`, default 30 s) instead of hanging. Expo, Capacitor,
+  `node:sqlite` and memory; IndexedDB refuses with an explanation. `AnchorSession` / `ClientSession`.
+- **Versioned migrations**: `createAnchorDB({ version, migrations: { 2: async (ctx) => … } })`, run by
+  `open()`, each step in its own transaction that records the version reached. A failed step is
+  rolled back and reported as `MigrationError`; `open()` can be retried. Older apps refuse newer data.
+- **Recovery**: open failures are `DatabaseOpenError`, or `CorruptDatabaseError` /
+  `DatabaseLockedError`, with the driver's error as `cause`. `db.reset()` deletes the storage even
+  when it no longer opens. `integrityCheck: true` runs `PRAGMA quick_check` on open.
+  `db.rebuildIndexes()` rebuilds index entries from the documents.
+- **TTL indexes are enforced.** `expireAfterSeconds` was stored and never applied; a sweep now deletes
+  expired documents with MongoDB's rules, every 60 s (`ttlIntervalMs`, `ttl: false`), and `db.expire()`
+  sweeps on demand.
+- **Encryption**: `ExpoSqliteAdapter({ encryptionKey })` opens the file with SQLCipher, and refuses
+  rather than store plain text when expo-sqlite is built without it.
+- **Observability**: `db:open`, `db:transaction` and `db:slowQuery` (with `slowQueryMs`) events, and
+  `db.diagnostics()` for the storage queue depth.
+- **`anchordb/testing`**: `fakeExpoSqlite` and `fakeCapacitorSqlite` run the real adapters in Node,
+  and `runAdapterConformance` holds any adapter to the storage contract. The Expo stand-in is the
+  expense-tracker team's, which found the 1.3.2 bugs.
+- **Default file name**: an Expo or Capacitor adapter built without a name takes the database's —
+  `new ExpoSqliteAdapter({ sqlite })` with `name: "expense-tracker"` opens `expense-tracker.db`.
+- `anchordb-react`: **`useAnchorStatus(db)`** documented as the way to render opening, failure and retry.
+- **Guides in the package**, under `docs/`: sync, concurrency and transactions, migrations / recovery
+  / TTL / encryption, aggregation, testing, the inspector. Sync existed since 1.0 but was never
+  explained, which is why the team built their own.
+- **Every package ships this changelog**, and each release is tagged on GitHub.
+
+### Changed
+
+- Every storage adapter queues all of its calls, reads included, per database. Concurrency was already
+  safe for writes in 1.3.3; reads now also never see another caller's uncommitted transaction.
+- An error from `open()` is now a `DatabaseOpenError` (message prefixed "The database did not open:")
+  instead of the driver's bare error, which is kept as `cause`. Code that matched on the message still
+  finds it inside.
+- `node:sqlite` adapter: prepared statements are dropped when the schema changes. One planned against
+  a partial index inside a transaction otherwise kept that plan and matched nothing when reused.
+
+### Not yet
+
+- Sync on a timer: `autoSync` and `intervalMs` are still reserved; call `db.sync.now()`.
+- Suspense for `useFind`; server-side expiry of sync delete markers; transactions on IndexedDB.
+
+## 1.3.3
+
+**Writes through Expo and Capacitor SQLite are safe under concurrency, and work on a device.** Found
+in an expense tracker on 1.3.2; every case below has a regression test.
+
+- **Concurrent writes no longer share a transaction** (Expo, Capacitor). Every driver call awaits each
+  statement, so two writes started together interleaved, and the second ran inside the first's
+  transaction: a write reported as failed could be partly saved, and one caller's rollback could undo
+  another's committed write. `SqlAdapterBase` now queues every driver call, reads included.
+- **Expo SQLite writes no longer fail with `database is locked`.** Inside
+  `withExclusiveTransactionAsync` statements now go to the `txn` connection expo-sqlite hands over,
+  instead of the outer one the exclusive lock blocks. Apps that mapped the exclusive transaction onto
+  `withTransactionAsync` as a workaround keep working.
+- **Concurrent upserts of the same new key** now insert once and update the rest, as MongoDB 4.2+ does,
+  instead of rejecting with E11000. A duplicate on some other unique field is still reported.
+- **A failed `db.open()` can be retried.** The rejection was cached, so a transient failure needed a
+  new `AnchorDB`.
+- **Duplicate-key errors name the configured database** — `expense-tracker.metas`, not
+  `anchor.metas`. `ExpoSqliteAdapter` defaults its name to the file name without `.db`, and
+  `createAnchorDB` passes `config.name`.
+- `anchordb-react`: **`useAnchorReady` no longer waits forever when the database fails to open.** It
+  throws the error during render, for an error boundary. The new `useAnchorStatus(db)` returns
+  `{ status, ready, error, retry }` to show the failure and retry in place, and `anchorOpenStore(db)`
+  is the store both read. Neither starts work while rendering any more.
+
+## 1.3.2
+
+Documentation only — no code changes.
+
+- **Bugs, support and feedback go to the AnchorDB project page**, at
+  [nisalanadeera.com/projects/anchordb](https://www.nisalanadeera.com/projects/anchordb#feedback): a form
+  that asks for the package, version and platform, and a reply by email.
+- Every package's npm **Homepage** is that page, and **Report a bug** (`npm bugs`) opens the form.
+- Every README links the overview and the form, and says what a bug report that can be acted on
+  includes.
+- The package READMEs' family tables list all six packages, with `anchordb-lens-link`.
+- All six packages move to 1.3.2 together.
+
+## 1.3.1
+
+**Lens Link keeps both apps running in the background.** Found on a phone: switching from the app to
+Anchor Lens let the phone stop the app within seconds, and the link went with it.
+
+- `anchordb-lens-link`: while the link is on, the app runs an Android foreground service with an
+  ongoing notification — *Anchor Lens Link on*, then *Anchor Lens connected* — which is what Android
+  lets an app use to keep running. `keepAlive: false` turns it off; `link.keepAliveError` says why it
+  could not start.
+- `startKeepAlive`, `updateKeepAlive` and `stopKeepAlive` keep a client running the same way. Anchor
+  Lens uses them while it is connected to an app, so you can switch between the two.
+- `backgroundStatus()`, `askNotificationPermission()`, `askBatteryUnrestricted()`,
+  `openNotificationSettings()` and `openBackgroundSettings()`: the permissions and settings that stop a
+  phone overruling it, including Xiaomi's Autostart screen.
+- Only `anchordb-lens-link` changes. The other packages stay at 1.3.0.
+
+## 1.3.0
+
+**Anchor Lens Link: open a QA build's database in Anchor Lens on the same phone, from a file.** Asked
+for after testing on a phone, where reaching another app took a laptop, the relay, an address, a room, a
+QR scan and a pairing code.
+
+- **New package, `anchordb-lens-link`.** `enableLensLink(db, { allowInProduction: true })` starts a
+  WebSocket server on 127.0.0.1, puts an `InspectorAgent` behind it and writes a sealed
+  `Android/media/<package>/anchor-lens/<database>.anchorlens`. In Anchor Lens, *Open app from file*
+  reads it, connects and authenticates with nothing typed. The port and the secret change every
+  launch. Android only; the native part is a small Expo module on Java-WebSocket. It is a separate
+  package, and does nothing unless the app calls it, so production apps need never ship it.
+- **`auth.sharedSecret` for the inspector.** An agent can authenticate a secret both sides already
+  hold instead of a code shown on screen. It is proved the same way, as an HMAC over a single-use
+  challenge, but it is not burned, so a client can reconnect; a spent or expired challenge is replaced
+  at once. Secrets shorter than 32 characters are refused. Pairing codes work as before.
+- **`assertInspectorAllowed` is exported**, so a package that starts an agent applies the same
+  production guard as the relay connection.
+- Tested in Node end to end: the sealed file, an agent with a shared secret behind a WebSocket server
+  that behaves like the native one, and a Lens client that reads the file, proves the secret, reads and
+  writes through the Model API, reconnects with the same file, and is shut out after `close()`.
+
+## 1.2.0
+
+Anchor Lens can create and drop indexes, and a malformed `_id` is refused instead of stored. Both
+found while testing Lens on a phone.
+
+- **Create Index and Drop Index on the inspector protocol.** `InspectorClient.createIndex(collection,
+  key, options)` and `dropIndex(collection, name)`, routed through `Model.createIndex()` and
+  `dropIndex()`. Agents had advertised `indexes:write` with no method behind it. Keys are checked
+  (`1` or `-1`, no `$` fields), read-only sessions refuse both, a unique index over values that already
+  collide fails with `duplicate_key`, and `_id_` cannot be dropped.
+- **`getSchema(collection)` on the inspector protocol** — a declared model's fields with their type,
+  required flag, enum and plain default, nested objects as dotted paths. What Lens needs to offer
+  "Add all fields" on Insert document. Validator functions and function defaults are not sent; a
+  collection with no declared model returns no fields.
+- **An insert stored an object `_id` as "[object Object]".** Insert skipped the `_id` handling updates
+  apply, and storage keys rows by the id's string form — so Extended JSON pasted into Lens, with
+  `{ "$oid": … }` read as a plain object, produced such a row, and every such document would have
+  collided on it. Objects that are not ObjectIds are now refused with a `CastError`. Strings and
+  numbers are kept, as the driver keeps them.
+
+## 1.1.0
+
+**Anchor Lens can read other apps.** Pointing Lens at a second app on a real phone found every step of
+that path broken or missing.
+
+- **`inspector: { enabled, relayUrl }` did nothing.** It ran a production check and never connected.
+  With `relayUrl` set the database now publishes itself to `anchor-relay` on construction, stays
+  connected, reconnects after a drop, and reports pairing codes through `inspector.onPairing` and the
+  `inspector:pairing` / `inspector:state` events. `db.inspector` exposes the connection, and
+  `connectInspectorToRelay(db, options)` does the same at runtime.
+- **Pairing asked for a 32-character hex challenge, typed on a phone.** The agent now sends it with
+  `connect` as `ConnectResult.challenge` — a nonce, not a secret; the code never leaves the app — and
+  opens a fresh pairing window, announcing its code, when the last one was spent or expired. Lens types
+  only the code.
+- **The production guard never fired on React Native.** It read `process.env.NODE_ENV` through
+  `globalThis`, which Metro does not inline, so a release build looked like development. `__DEV__ ===
+  false` now counts as production too.
+- **`anchordb-relay`:**
+  - With `--host 0.0.0.0` it printed `ws://0.0.0.0:9440` — the listen address, which no device can
+    dial. It now prints the machine's network addresses.
+  - It prints the Lens link as a QR code in the terminal.
+  - `--room <id>` fixes the room, so an app built with the agent URL survives relay restarts.
+  - The room it printed was reclaimed after 30 idle minutes, so an app connecting later got "unknown
+    room". It is now kept for the life of the relay.
+  - Stopping it hung while an app or Lens was connected: neither `wss.close` nor `http.close` ends
+    established connections. They are now terminated.
+- Tested over real sockets: a relay server, an app publishing with `connectInspectorToRelay`, and a Lens
+  client that pairs with only the code, reads and writes, then shuts down cleanly.
+
+## 1.0.6
+
+Crash on launch in React Native apps that load `anchordb` before `anchordb-react`.
+
+- **Importing `anchordb` needed a crypto source.** `ObjectId` drew its per-process random block and
+  its counter seed when the module loaded. On React Native, `globalThis.crypto` comes from the
+  `react-native-get-random-values` polyfill that `anchordb-react` loads — so an app that evaluated
+  `anchordb` first died with `No cryptographically secure random source is available` before it
+  generated a single id. Lens React did exactly that through a re-export and closed the instant it
+  launched on a phone; the Contacts app survived only because its first import happened to be
+  `createAnchorDB`. Both values are now drawn on the first `ObjectId`, and a failed draw caches
+  nothing, so a polyfill that loads later still works.
+- The error message now points React Native users at `anchordb-react`'s `createAnchorDB`.
+- A new test imports the whole package with no crypto source. Without this fix it fails with the
+  original error.
+
+## 1.0.5
+
+Inspector fix, found by building Anchor Lens on a database on the device.
+
+- **Schemaless collections were reported to Lens as schema-backed.** `db.collection(name)` — which
+  the inspector agent uses for any collection without a model, including every collection Lens
+  creates by inserting into it — registers an internal `__collection__<name>` model.
+  `getCollections` counted it as a schema, so Lens showed `hasSchema: true` and a model pill reading
+  `__collection__notes` instead of "schemaless". The agent now reports only models the app declared.
+- **`modelForCollection` returned whichever model registered first.** A collection reached through
+  `db.collection()` before its model was declared resolved to the schemaless model, so an export
+  emitted ObjectIds and Dates as bare strings. A declared model now always wins.
+
+## 1.0.4
+
+`anchordb-angular` in native Capacitor builds. No change to database behaviour.
+
+- **Capacitor links native plugins only from the package.json of the app.** `@capacitor-community/sqlite`
+  arrives through `anchordb-angular`, so it was installed but `npx cap sync` left it out of the
+  Android project — found by building the Ionic test app, whose `capacitor.settings.gradle` had no
+  SQLite plugin. On a device the first query would have failed with
+  `"CapacitorSQLite" plugin is not implemented on android`. `ionicAdapter` now checks
+  `Capacitor.isPluginAvailable("CapacitorSQLite")` and throws naming
+  `npm install @capacitor-community/sqlite` and `npx cap sync`. It does not fall back to IndexedDB,
+  which would strand the data in a store the app abandons once the plugin is linked.
+- **`@capacitor/core` was declared `^8.5.2` and `@capacitor-community/sqlite` `^8.1.1`** — the same
+  `npm install -w` caret rewrite as `anchordb-react` 1.0.1. A Capacitor 6 or 7 app would have got a
+  second `@capacitor/core`, and plugins registered on one instance are invisible to the other. Both
+  are now `>=6`, held by a regression test.
+- The README and package reference showed `inject(AnchorService)` and `AnchorModule.forRoot(...)`
+  inside `imports`. Neither works: the providers use string tokens, and `forRoot` returns plain
+  providers. Both now show `@Inject("AnchorService")` and spread `.providers`.
+- Verified in the Ionic test app on Capacitor 8.5.2: with the plugin listed, `cap sync` reports
+  `@capacitor-community/sqlite@8.1.1` for Android and the Gradle settings include it.
+
+## 1.0.3
+
+Guidance fix for Expo apps. No change to database behaviour.
+
+- **`createAnchorDB` and the `anchordb-react` README recommended `npx expo install --fix`**, which
+  cannot help: it only realigns packages listed in the package.json of the app, and `expo-sqlite`
+  and `react-native-get-random-values` arrive through `anchordb-react`. Both now name
+  `npx expo install expo-sqlite react-native-get-random-values`, which pins the drivers at the top
+  level where the wide ranges from 1.0.2 dedupe onto them.
+- Verified in an Expo SDK 56 app: with the pins, both drivers resolve to the versions the SDK pins
+  (`expo-sqlite` 56.0.6, `react-native-get-random-values` 1.11.0), deduped, and
+  `npx expo install --check` reports dependencies up to date. Without the pin the polyfill resolves
+  to 2.0.0 against the 1.11 native module Expo Go ships.
+
+## 1.0.2
+
+`anchordb-react` pinned its native drivers to a single Expo SDK.
+
+- **`expo-sqlite` was declared `^57.0.3`**, so an app on Expo SDK 56 (`expo-sqlite ~56.0.4`) could
+  not dedupe it. npm nested a second, SDK 57 `expo-sqlite` whose JavaScript no longer matched the
+  native build of the app. The intended range was `>=14`; `npm install -w` rewrote it with a caret
+  when the dependency was added. Both drivers now take wide ranges (`expo-sqlite >=14`,
+  `react-native-get-random-values >=1.11`), so npm reuses whatever version the Expo SDK of the app
+  already installed.
+- A test now asserts both ranges accept the drivers Expo SDK 56 and 57 ship and are not caret- or
+  tilde-pinned, so a future `npm install -w` cannot silently narrow them again.
+
+Found by comparing against a working Expo SDK 56 app on the same machine.
+
+## 1.0.1
+
+Two defects in `anchordb-angular`, both in its *documented* usage, found by building a real Ionic
+app against the published package for the first time.
+
+- **The provider arrays did not typecheck against Angular.** `Provider.useFactory` was declared
+  optional, so the array was not assignable to Angular’s `Provider[]` and the documented
+  `bootstrapApplication` example failed to compile. It is now required, matching what every
+  provider in the package actually returns, and `useValue` — declared but never used — is gone.
+- **`.toObservable()` was documented but implemented nowhere.** The real API is
+  `AnchorService.find$` / `findOne$` / `count$`, which return an RxJS-interop `AnchorObservable`
+  the `async` pipe accepts directly. The documentation now shows that.
+
+## 1.0.0
+
+**Versioning changes with this release.** The major version now tracks the React / Angular major the
+packages are built against: React 18 stays on the `0.x` line, React 19 begins at `1.x`. Projects on
+React 18 remain on 0.2.1, preserved on the
+[`release/0.x-react18`](https://github.com/knnadeera/anchordb/tree/release/0.x-react18) branch.
+
+### One install, ready to use
+
+`npm install anchordb-react` now brings the database, the SQLite driver and the crypto polyfill —
+and `createAnchorDB({ name })` needs no adapter wiring. `npm install anchordb-angular` does the
+same, with `provideAnchorIonic` choosing Capacitor SQLite on a device and IndexedDB under
+`ionic serve`.
+
+- `anchordb-react` gains `createAnchorDB`, and depends on `expo-sqlite` and
+  `react-native-get-random-values`
+- `anchordb-angular` gains `ionicAdapter` and `provideAnchorIonic`, and depends on
+  `@capacitor/core` and `@capacitor-community/sqlite`
+
+### Breaking
+
+- **`anchordb-react` is now React Native only.** It imports `react-native-get-random-values`, which
+  imports React Native internals, so a React web build fails. Browser apps use `anchordb` directly
+  with `anchordb/storage/indexeddb`, which is unchanged.
+- **React 19 is required** by `anchordb-react`, since `expo-sqlite` pulls React Native.
+
+### Fixed
+
+- **Subpath imports were unusable under `moduleResolution: Node10`.** Neither `anchordb` nor
+  `anchordb-sync-server` declared `typesVersions`, so `anchordb/storage/expo-sqlite` and friends
+  resolved to nothing for any consumer on classic resolution — and broke this repo's own CommonJS
+  build. Every `node10` result in are-the-types-wrong is now green where most were previously
+  failing.
+- **The `ExpoDatabase` interface did not match the real `expo-sqlite`.** `params` was declared
+  optional where the driver requires it, and typed `unknown[]` where SQLite accepts only five bind
+  types. The actual module was therefore not assignable to the interface, so every TypeScript user
+  following the documented usage got an error. Caught by typechecking against the real package for
+  the first time.
+- **`sideEffects: false` on `anchordb-react`** would have let a bundler tree-shake away the crypto
+  polyfill, making the first `ObjectId` throw. It now names the built entries.
+
+## 0.2.1
+
+Documentation and discoverability only — no code changes.
+
+- Every package README now carries a **The AnchorDB family** table, so someone landing on
+  `anchordb-react` from an npm search can see the other four and what each is for.
+- npm keywords added to `anchordb-react`, `anchordb-angular`, `anchordb-sync-server` and
+  `anchordb-relay`, which had none and so did not surface in npm search at all. `anchordb` gained
+  aggregation, schema and document-database terms.
+- Corrected stale `0.1.0` version claims in three READMEs.
+
+## 0.2.0 — first published release
+
+Published as the unscoped `anchordb` family. The `@anchor` scope was never available: it needs an
+npm organization, so the packages took unscoped names instead.
+
+### Added
+
+- **Bulk writes on the inspector protocol** — `updateMany` and `deleteMany`, behind a new
+  `documents:bulk` capability, routed through the ordinary Model API so a bulk write from Anchor
+  Lens validates, stamps and queues exactly like an app write. An empty filter is refused unless
+  explicitly acknowledged.
+- **CSV export and import** (`toCsv`, `fromCsv`, `detectImportFormat`), matching
+  `mongoexport --type=csv`. Values are cast through the collection schema on import.
+- **A `filter` option on export**, for exporting query results rather than a whole collection.
+- **A `default` Extended JSON mode**, alongside `relaxed` and `canonical`.
+- **A MongoDB bridge** (`MongoBridgeClient` here, `MongoBridge` in `anchordb-relay`), so Lens can
+  pull collections from a real MongoDB or push a device into one.
+
+### Fixed
+
+- **`modifiedCount` could never be 0.** `updatedAt` and the version key were stamped before the
+  change comparison, so every matched document counted as modified and a no-op still bumped the
+  timestamp. A no-op update is now matched but not modified, and writes nothing — which also stops a
+  bulk update over 10,000 documents queueing 10,000 mutations when only a few hundred changed.
+- **`MongooseStore` was never exported** from `anchordb-sync-server`, so it was absent from the
+  published types and unreachable by anyone following the README.
+
+## 0.1.0 — never published
+
+The initial implementation. Superseded by 0.2.0 before anything reached npm.
+
+First release. Five packages, published together.
+
+### `anchordb`
+
+- **Local-first database** with a Mongoose-shaped API. No `sync` block means a purely local
+  database: no mutation queue, no network code, no sync metadata, hard deletes.
+- **Mongoose parity**: `Schema`, `model()`, documents with `.save()`/`.isModified()`, virtuals,
+  methods, statics, `pre`/`post` hooks, `ValidationError`/`CastError` shapes, and `code: 11000`.
+- **Decorators** (`anchordb/decorators`) matching `@nestjs/mongoose` — `@Schema`, `@Prop`,
+  `SchemaFactory`, `raw()` — so one decorated class can be shared with a NestJS backend.
+  Metadata is optional: explicit `@Prop(String)` works with `emitDecoratorMetadata` off.
+- **Real MongoDB ObjectId**, generated on-device, cross-validated byte-for-byte against `bson`.
+- **Indexes** — single, compound, multikey, `unique`, `sparse`, `partialFilterExpression`, TTL —
+  with unique violations enforced at the storage layer and reported as `E11000`.
+- **Lazy chainable query builder**: `.populate().sort().skip().limit().select().exec()`, thenable,
+  async-iterable, with `explain()`.
+- **Aggregation pipeline** with streaming execution, index pushdown, and a `mongoCompatible` strict
+  mode that rejects non-portable constructs at development time.
+- **UTC-canonical timestamps** with IANA timezone support, validated at construction.
+- **Extended JSON v2 interop** — `export()` feeds `mongoimport`; `mongoexport` output imports back.
+- **Offline mutation queue** and sync engine with five conflict strategies
+  (`last-write-wins`, `server-wins`, `client-wins`, `field-level`, `custom`).
+- **Inspector protocol v1** with pairing, sessions, and live change events.
+- **Five storage adapters**: Memory, Node SQLite, IndexedDB, Expo SQLite, Capacitor SQLite.
+
+### `anchordb-sync-server`
+
+- Framework-agnostic protocol engine over a pluggable `ServerStore`.
+- Express, NestJS and Next.js adapters, all held to one conformance suite.
+- `MemoryStore` (default) and `MongooseStore`.
+
+### `anchordb-react`
+
+- `useFind`, `useFindOne`, `useCount`, `useAggregate`, `useSyncStatus`, `useAnchorEvent`.
+
+### `anchordb-angular`
+
+- `AnchorModule.forRoot`/`forFeature`, `getModelToken`, `AnchorService` with RxJS-compatible
+  observables. Angular and RxJS are optional peers and are never imported.
+
+### `anchordb-relay`
+
+- Development-only WebSocket relay plus the `anchor-relay` CLI.
+
+### Known limitations
+
+- **Expo SQLite and Capacitor SQLite are unverified** — written and typechecked, never executed on
+  a device. Test before production use.
+- The REST sync transport and `MongooseStore` have no live-server tests.
+- Not supported in v1: discriminators, `refPath`, transactions, server-side change streams,
+  text/geo/hashed indexes, collation, and the `$graphLookup`/`$geoNear`/`$search`/`$merge`/`$out`/
+  `$unionWith` aggregation stages.

package/README.md

@@ -133,6 +133,12 @@ Each one needs a different third-party framework as a peer dependency, and npm r
 package rather than per import — which is why they are not one package. Full reasoning and API
 reference: [github.com/knnadeera/anchordb](https://github.com/knnadeera/anchordb).
 
+## Changes
+
+What changed in each version is in [CHANGELOG.md](./CHANGELOG.md), shipped in this package — one
+changelog for the whole family, since all six packages are released together. Releases are also
+tagged on [GitHub](https://github.com/knnadeera/anchordb/releases).
+
 ## Bugs, support and feedback
 
 Report a bug, ask for help or suggest a feature on the [AnchorDB project page](https://www.nisalanadeera.com/projects/anchordb#feedback) —

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anchordb-angular",
-  "version": "1.3.3",
+  "version": "1.4.1",
   "license": "MIT",
   "type": "module",
   "sideEffects": false,
@@ -23,7 +23,8 @@
   "files": [
     "dist",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "CHANGELOG.md"
   ],
   "scripts": {
     "build": "rimraf dist && tsc -p tsconfig.build.json && tsc -p tsconfig.build.cjs.json && node ../core/scripts/finalize-dist.mjs",
@@ -34,7 +35,7 @@
   "dependencies": {
     "@capacitor-community/sqlite": ">=6",
     "@capacitor/core": ">=6",
-    "anchordb": "^1.3.3"
+    "anchordb": "^1.4.1"
   },
   "devDependencies": {
     "rimraf": "^6.0.1"