@thadeu/ndb 0.1.1 → 0.1.2

package/README.md

@@ -86,30 +86,28 @@ const results = await calls.insert([
 // Find by id. Returns null when missing.
 const row = await calls.find('c1')
 
-// Update with optimistic locking.
-await calls.update('c1', { status: 'done' }, { ifVersion: row!._v })
+// Atomic update by filter: filter first, then the write operators.
+// _v in the filter is an optimistic lock.
+const res = await calls.update({ call_id: 'c1', _v: row!._v }, { $set: { status: 'done' }, $unset: { duration: true } })
+// res: { matched, modified, doc } (doc is the new row with _v; absent for many)
 
-// Remove a field.
-await calls.update('c1', {}, { unset: ['duration'] })
+// A guarded decrement: exactly one of two racing calls wins.
+await stock.update({ sku: 'a', qty: { $gte: 1 } }, { $inc: { qty: -1 } })
 
-// Delete. ifVersion is optional here too.
-await calls.delete('c1', { ifVersion: 3 })
-```
-
-`update` returns `{ id, v }` with the new version. A stale `ifVersion` throws `VersionConflictError`:
+// Every match (the filter needs the id or an indexed field), or create it.
+await calls.update({ status: 'failed' }, { $set: { status: 'retry' } }, { many: true })
+await calls.update({ call_id: 'c9' }, { $inc: { duration: 1 } }, { upsert: true })
 
-```ts
-import { VersionConflictError } from '@thadeu/ndb'
-
-try {
-  await calls.update('c1', { status: 'x' }, { ifVersion: row!._v })
-} catch (err) {
-  if (err instanceof VersionConflictError) {
-    // Someone else wrote first. Read again and retry.
-  }
-}
+// Delete by filter: { deleted }.
+await calls.delete({ call_id: 'c2' })
+await calls.delete({ status: 'failed' }, { many: true })
 ```
 
+- Operators: `$set`, `$unset`, `$inc`, `$push` (with `{ $each: [...] }`), `$pull`, `$min`, `$max`. Field names can be dot paths.
+- Nothing matched is not an error: `matched` is 0 (for example when `_v` is stale, so read again and retry). `modified` is 0 when the operators leave the document as it is.
+- `many` needs the id or an indexed field in the filter. `upsert` creates the document from the equality fields of the filter.
+- A key of the operators without `$` throws `InvalidUpdateError` before anything is sent. The daemon contract errors (`unknown_operator`, `no_update`, `conflicting_update`, `invalid_field`, `unindexed_many`, `empty_filter`) are `InvalidUpdateError` too.
+
 An insert with a duplicate id throws `DuplicateIdError`. A duplicate `unique` value throws `UniqueViolationError`. An insert without the id when the schema names one fails with code `missing_id`.
 
 ### Expiry (TTL like Redis)
@@ -122,7 +120,7 @@ const sessions = db.model('sessions', {
 })
 
 await sessions.insert({ sid: 's1' }, { expireIn: '1h' }) // or 3600; all docs of the call
-await sessions.update('s1', { user: 'u' }, { expireIn: '30m' })
+await sessions.update({ sid: 's1' }, { $set: { user: 'u' } }, { expireIn: '30m' })
 
 const { v, expiresAt } = await sessions.expire('s1', '30m') // EXPIRE
 await sessions.expireAt('s1', new Date(Date.now() + 3_600_000))
@@ -268,7 +266,6 @@ Daemon errors are `NdbError` or a subclass. They have `code` (the daemon code) a
 |---|---|
 | `UnauthorizedError` | `unauthorized` |
 | `NotFoundError` | `not_found`, `unknown_collection` |
-| `VersionConflictError` | `version_conflict` |
 | `DuplicateIdError` | `duplicate_id` |
 | `UniqueViolationError` | `unique_violation` |
 | `InvalidQueryError` | `invalid_query`, `invalid_pipeline` |
@@ -276,6 +273,7 @@ Daemon errors are `NdbError` or a subclass. They have `code` (the daemon code) a
 | `WatchLaggedError` | `watch_lagged` |
 | `HistoryTruncatedError` | `history_truncated` |
 | `TtlError` | `ttl_not_enabled`, `ttl_derived` |
+| `InvalidUpdateError` | `unknown_operator`, `no_update`, `conflicting_update`, `invalid_field`, `unindexed_many`, `empty_filter`, `invalid_update` |
 | `NdbError` | every other code: `not_ready`, `catalog_conflict`, `catalog_invalid`, `direct_collection`, `invalid_request`, `group_limit_exceeded`, `request_too_large`, `line_too_large`, `closed`, `invalid_position`, `http_status`, ... |
 
 ```ts

package/dist/index.cjs

@@ -24,6 +24,7 @@ __export(index_exports, {
   DuplicateIdError: () => DuplicateIdError,
   HistoryTruncatedError: () => HistoryTruncatedError,
   InvalidQueryError: () => InvalidQueryError,
+  InvalidUpdateError: () => InvalidUpdateError,
   Model: () => Model,
   Ndb: () => Ndb,
   NdbError: () => NdbError,
@@ -32,7 +33,6 @@ __export(index_exports, {
   TtlError: () => TtlError,
   UnauthorizedError: () => UnauthorizedError,
   UniqueViolationError: () => UniqueViolationError,
-  VersionConflictError: () => VersionConflictError,
   WatchLaggedError: () => WatchLaggedError,
   connect: () => connect,
   makeError: () => makeError
@@ -54,8 +54,6 @@ var UnauthorizedError = class extends NdbError {
 };
 var NotFoundError = class extends NdbError {
 };
-var VersionConflictError = class extends NdbError {
-};
 var DuplicateIdError = class extends NdbError {
 };
 var UniqueViolationError = class extends NdbError {
@@ -68,13 +66,14 @@ var WatchLaggedError = class extends NdbError {
 };
 var HistoryTruncatedError = class extends NdbError {
 };
+var InvalidUpdateError = class extends NdbError {
+};
 var TtlError = class extends NdbError {
 };
 var subclasses = {
   unauthorized: UnauthorizedError,
   not_found: NotFoundError,
   unknown_collection: NotFoundError,
-  version_conflict: VersionConflictError,
   duplicate_id: DuplicateIdError,
   unique_violation: UniqueViolationError,
   invalid_query: InvalidQueryError,
@@ -85,7 +84,13 @@ var subclasses = {
   watch_lagged: WatchLaggedError,
   history_truncated: HistoryTruncatedError,
   ttl_not_enabled: TtlError,
-  ttl_derived: TtlError
+  ttl_derived: TtlError,
+  unknown_operator: InvalidUpdateError,
+  no_update: InvalidUpdateError,
+  conflicting_update: InvalidUpdateError,
+  invalid_field: InvalidUpdateError,
+  unindexed_many: InvalidUpdateError,
+  empty_filter: InvalidUpdateError
 };
 function makeError(code, message, status = 0) {
   const Cls = subclasses[code] ?? NdbError;
@@ -291,23 +296,35 @@ var Model = class {
   create(docs, opts = {}) {
     return this.insert(docs, opts);
   }
-  async update(id, set, opts = {}) {
+  // Atomic update by filter. The filter and the operators are sent as one
+  // body; the daemon matches and writes in one step on the newest state, so
+  // concurrent updates never interleave. A version guard is a filter:
+  // { call_id: 'c1', _v: 7 }. Matching nothing is not an error: matched is 0.
+  async update(filter, ops, opts = {}) {
     await this.ready();
-    const update = { id, set, unset: opts.unset, if_version: opts.ifVersion, expire_in: opts.expireIn };
-    return this.db.transport.request("POST", this.path("update"), { update });
+    const body = mergeUpdate(filter, ops);
+    const query = writeQuery({ many: opts.many, upsert: opts.upsert, expire_in: opts.expireIn });
+    const out = await this.db.transport.request(
+      "POST",
+      this.path("update") + query,
+      body
+    );
+    return { matched: out.matched, modified: out.modified, doc: out.doc && this.decode(out.doc) };
   }
-  async delete(id, opts = {}) {
+  // Deletes the documents that the filter matches: one, or every match with
+  // many (same rule as update).
+  async delete(filter, opts = {}) {
     await this.ready();
-    await this.db.transport.request("POST", this.path("delete"), { delete: { id, if_version: opts.ifVersion } });
+    return this.db.transport.request("POST", this.path("delete") + writeQuery({ many: opts.many }), toWhere(filter));
   }
   // Makes a document expire, like EXPIRE in Redis: seconds or "30m". It throws
   // NotFoundError for a missing or expired document, and TtlError when the
   // schema has no expires field.
-  expire(id, duration, opts = {}) {
-    return this.setExpiry({ id, in: duration, if_version: opts.ifVersion });
+  expire(id, duration) {
+    return this.setExpiry({ id, in: duration });
   }
-  expireAt(id, at, opts = {}) {
-    return this.setExpiry({ id, at: at.toISOString(), if_version: opts.ifVersion });
+  expireAt(id, at) {
+    return this.setExpiry({ id, at: at.toISOString() });
   }
   // Removes the expiry of a document (PERSIST in Redis).
   async persist(id) {
@@ -419,6 +436,24 @@ var Model = class {
     };
   }
 };
+function writeQuery(params) {
+  const q = new URLSearchParams();
+  for (const [name, value] of Object.entries(params)) {
+    if (value !== void 0 && value !== false) {
+      q.set(name, String(value));
+    }
+  }
+  const text = q.toString();
+  return text === "" ? "" : `?${text}`;
+}
+function mergeUpdate(filter, ops) {
+  for (const key of Object.keys(ops)) {
+    if (!key.startsWith("$")) {
+      throw new InvalidUpdateError("invalid_update", `update operator "${key}" must start with $ (for example "$set")`);
+    }
+  }
+  return { ...toWhere(filter), ...ops };
+}
 
 // src/transport.ts
 var import_undici = require("undici");
@@ -624,6 +659,7 @@ function connect(addr, opts) {
   DuplicateIdError,
   HistoryTruncatedError,
   InvalidQueryError,
+  InvalidUpdateError,
   Model,
   Ndb,
   NdbError,
@@ -632,7 +668,6 @@ function connect(addr, opts) {
   TtlError,
   UnauthorizedError,
   UniqueViolationError,
-  VersionConflictError,
   WatchLaggedError,
   connect,
   makeError

package/dist/index.d.cts

@@ -66,14 +66,38 @@ interface WriteResult {
     id: string;
     v: number;
 }
-interface WriteOptions {
-    ifVersion?: number;
-}
 type Duration = number | string;
-interface UpdateOptions extends WriteOptions {
-    unset?: string[];
+type Filter<F extends Fields> = Where<F> & {
+    _v?: number | Ops<number>;
+    $and?: Filter<F>[];
+    $or?: Filter<F>[];
+    $nor?: Filter<F>[];
+};
+interface UpdateOps<F extends Fields = Fields> {
+    $set?: Input<F> & Record<string, unknown>;
+    $unset?: Record<string, true | ''>;
+    $inc?: Record<string, number>;
+    $push?: Record<string, unknown>;
+    $pull?: Record<string, unknown>;
+    $min?: Record<string, number | string>;
+    $max?: Record<string, number | string>;
+}
+interface UpdateOptions {
+    many?: boolean;
+    upsert?: boolean;
     expireIn?: Duration;
 }
+interface DeleteOptions {
+    many?: boolean;
+}
+interface UpdateResult<F extends Fields = Fields> {
+    matched: number;
+    modified: number;
+    doc?: Row<F>;
+}
+interface DeleteResult {
+    deleted: number;
+}
 interface InsertOptions {
     expireIn?: Duration;
 }
@@ -150,10 +174,10 @@ declare class Model<F extends Fields> {
     ready(): Promise<void>;
     insert(docs: Input<F> | Input<F>[], opts?: InsertOptions): Promise<WriteResult[]>;
     create(docs: Input<F> | Input<F>[], opts?: InsertOptions): Promise<WriteResult[]>;
-    update(id: string, set: Input<F>, opts?: UpdateOptions): Promise<WriteResult>;
-    delete(id: string, opts?: WriteOptions): Promise<void>;
-    expire(id: string, duration: Duration, opts?: WriteOptions): Promise<ExpireResult>;
-    expireAt(id: string, at: Date, opts?: WriteOptions): Promise<ExpireResult>;
+    update(filter: Filter<F>, ops: UpdateOps<F>, opts?: UpdateOptions): Promise<UpdateResult<F>>;
+    delete(filter: Filter<F>, opts?: DeleteOptions): Promise<DeleteResult>;
+    expire(id: string, duration: Duration): Promise<ExpireResult>;
+    expireAt(id: string, at: Date): Promise<ExpireResult>;
     persist(id: string): Promise<WriteResult>;
     ttl(id: string): Promise<number | null>;
     private setExpiry;
@@ -215,7 +239,7 @@ declare class Ndb {
 }
 declare function connect(addr?: string, opts?: ConnectOptions): Ndb;
 
-type ErrorCode = 'unauthorized' | 'not_found' | 'version_conflict' | 'duplicate_id' | 'unique_violation' | 'catalog_conflict' | 'catalog_invalid' | 'unknown_collection' | 'direct_collection' | 'invalid_request' | 'invalid_query' | 'invalid_pipeline' | 'group_limit_exceeded' | 'cursor_invalid' | 'cursor_mismatch' | 'cursor_expired' | 'request_too_large' | 'line_too_large' | 'not_ready' | 'closed' | 'watch_lagged' | 'invalid_position' | 'history_truncated' | 'ttl_not_enabled' | 'ttl_derived' | 'http_status' | (string & {});
+type ErrorCode = 'unauthorized' | 'not_found' | 'duplicate_id' | 'unique_violation' | 'catalog_conflict' | 'catalog_invalid' | 'unknown_collection' | 'direct_collection' | 'invalid_request' | 'invalid_query' | 'invalid_pipeline' | 'group_limit_exceeded' | 'cursor_invalid' | 'cursor_mismatch' | 'cursor_expired' | 'request_too_large' | 'line_too_large' | 'not_ready' | 'closed' | 'watch_lagged' | 'invalid_position' | 'history_truncated' | 'ttl_not_enabled' | 'ttl_derived' | 'unknown_operator' | 'no_update' | 'conflicting_update' | 'invalid_field' | 'unindexed_many' | 'empty_filter' | 'invalid_update' | 'http_status' | (string & {});
 declare class NdbError extends Error {
     readonly code: ErrorCode;
     readonly status: number;
@@ -225,8 +249,6 @@ declare class UnauthorizedError extends NdbError {
 }
 declare class NotFoundError extends NdbError {
 }
-declare class VersionConflictError extends NdbError {
-}
 declare class DuplicateIdError extends NdbError {
 }
 declare class UniqueViolationError extends NdbError {
@@ -239,9 +261,11 @@ declare class WatchLaggedError extends NdbError {
 }
 declare class HistoryTruncatedError extends NdbError {
 }
+declare class InvalidUpdateError extends NdbError {
+}
 declare class TtlError extends NdbError {
 }
 declare function makeError(code: ErrorCode, message: string, status?: number): NdbError;
 
-export { CursorError, DuplicateIdError, HistoryTruncatedError, InvalidQueryError, Model, Ndb, NdbError, NotFoundError, Query, TtlError, UnauthorizedError, UniqueViolationError, VersionConflictError, WatchLaggedError, connect, makeError };
-export type { AggregateOptions, AggregateResult, ConnectOptions, Doc, Duration, ErrorCode, ExpireResult, FieldDef, FieldType, Fields, Input, InsertOptions, Ops, Row, Schema, SortSpec, TypeMap, UpdateOptions, WatchEvent, WatchOptions, Where, WriteOptions, WriteResult };
+export { CursorError, DuplicateIdError, HistoryTruncatedError, InvalidQueryError, InvalidUpdateError, Model, Ndb, NdbError, NotFoundError, Query, TtlError, UnauthorizedError, UniqueViolationError, WatchLaggedError, connect, makeError };
+export type { AggregateOptions, AggregateResult, ConnectOptions, DeleteOptions, DeleteResult, Doc, Duration, ErrorCode, ExpireResult, FieldDef, FieldType, Fields, Filter, Input, InsertOptions, Ops, Row, Schema, SortSpec, TypeMap, UpdateOps, UpdateOptions, UpdateResult, WatchEvent, WatchOptions, Where, WriteResult };

package/dist/index.d.ts

@@ -66,14 +66,38 @@ interface WriteResult {
     id: string;
     v: number;
 }
-interface WriteOptions {
-    ifVersion?: number;
-}
 type Duration = number | string;
-interface UpdateOptions extends WriteOptions {
-    unset?: string[];
+type Filter<F extends Fields> = Where<F> & {
+    _v?: number | Ops<number>;
+    $and?: Filter<F>[];
+    $or?: Filter<F>[];
+    $nor?: Filter<F>[];
+};
+interface UpdateOps<F extends Fields = Fields> {
+    $set?: Input<F> & Record<string, unknown>;
+    $unset?: Record<string, true | ''>;
+    $inc?: Record<string, number>;
+    $push?: Record<string, unknown>;
+    $pull?: Record<string, unknown>;
+    $min?: Record<string, number | string>;
+    $max?: Record<string, number | string>;
+}
+interface UpdateOptions {
+    many?: boolean;
+    upsert?: boolean;
     expireIn?: Duration;
 }
+interface DeleteOptions {
+    many?: boolean;
+}
+interface UpdateResult<F extends Fields = Fields> {
+    matched: number;
+    modified: number;
+    doc?: Row<F>;
+}
+interface DeleteResult {
+    deleted: number;
+}
 interface InsertOptions {
     expireIn?: Duration;
 }
@@ -150,10 +174,10 @@ declare class Model<F extends Fields> {
     ready(): Promise<void>;
     insert(docs: Input<F> | Input<F>[], opts?: InsertOptions): Promise<WriteResult[]>;
     create(docs: Input<F> | Input<F>[], opts?: InsertOptions): Promise<WriteResult[]>;
-    update(id: string, set: Input<F>, opts?: UpdateOptions): Promise<WriteResult>;
-    delete(id: string, opts?: WriteOptions): Promise<void>;
-    expire(id: string, duration: Duration, opts?: WriteOptions): Promise<ExpireResult>;
-    expireAt(id: string, at: Date, opts?: WriteOptions): Promise<ExpireResult>;
+    update(filter: Filter<F>, ops: UpdateOps<F>, opts?: UpdateOptions): Promise<UpdateResult<F>>;
+    delete(filter: Filter<F>, opts?: DeleteOptions): Promise<DeleteResult>;
+    expire(id: string, duration: Duration): Promise<ExpireResult>;
+    expireAt(id: string, at: Date): Promise<ExpireResult>;
     persist(id: string): Promise<WriteResult>;
     ttl(id: string): Promise<number | null>;
     private setExpiry;
@@ -215,7 +239,7 @@ declare class Ndb {
 }
 declare function connect(addr?: string, opts?: ConnectOptions): Ndb;
 
-type ErrorCode = 'unauthorized' | 'not_found' | 'version_conflict' | 'duplicate_id' | 'unique_violation' | 'catalog_conflict' | 'catalog_invalid' | 'unknown_collection' | 'direct_collection' | 'invalid_request' | 'invalid_query' | 'invalid_pipeline' | 'group_limit_exceeded' | 'cursor_invalid' | 'cursor_mismatch' | 'cursor_expired' | 'request_too_large' | 'line_too_large' | 'not_ready' | 'closed' | 'watch_lagged' | 'invalid_position' | 'history_truncated' | 'ttl_not_enabled' | 'ttl_derived' | 'http_status' | (string & {});
+type ErrorCode = 'unauthorized' | 'not_found' | 'duplicate_id' | 'unique_violation' | 'catalog_conflict' | 'catalog_invalid' | 'unknown_collection' | 'direct_collection' | 'invalid_request' | 'invalid_query' | 'invalid_pipeline' | 'group_limit_exceeded' | 'cursor_invalid' | 'cursor_mismatch' | 'cursor_expired' | 'request_too_large' | 'line_too_large' | 'not_ready' | 'closed' | 'watch_lagged' | 'invalid_position' | 'history_truncated' | 'ttl_not_enabled' | 'ttl_derived' | 'unknown_operator' | 'no_update' | 'conflicting_update' | 'invalid_field' | 'unindexed_many' | 'empty_filter' | 'invalid_update' | 'http_status' | (string & {});
 declare class NdbError extends Error {
     readonly code: ErrorCode;
     readonly status: number;
@@ -225,8 +249,6 @@ declare class UnauthorizedError extends NdbError {
 }
 declare class NotFoundError extends NdbError {
 }
-declare class VersionConflictError extends NdbError {
-}
 declare class DuplicateIdError extends NdbError {
 }
 declare class UniqueViolationError extends NdbError {
@@ -239,9 +261,11 @@ declare class WatchLaggedError extends NdbError {
 }
 declare class HistoryTruncatedError extends NdbError {
 }
+declare class InvalidUpdateError extends NdbError {
+}
 declare class TtlError extends NdbError {
 }
 declare function makeError(code: ErrorCode, message: string, status?: number): NdbError;
 
-export { CursorError, DuplicateIdError, HistoryTruncatedError, InvalidQueryError, Model, Ndb, NdbError, NotFoundError, Query, TtlError, UnauthorizedError, UniqueViolationError, VersionConflictError, WatchLaggedError, connect, makeError };
-export type { AggregateOptions, AggregateResult, ConnectOptions, Doc, Duration, ErrorCode, ExpireResult, FieldDef, FieldType, Fields, Input, InsertOptions, Ops, Row, Schema, SortSpec, TypeMap, UpdateOptions, WatchEvent, WatchOptions, Where, WriteOptions, WriteResult };
+export { CursorError, DuplicateIdError, HistoryTruncatedError, InvalidQueryError, InvalidUpdateError, Model, Ndb, NdbError, NotFoundError, Query, TtlError, UnauthorizedError, UniqueViolationError, WatchLaggedError, connect, makeError };
+export type { AggregateOptions, AggregateResult, ConnectOptions, DeleteOptions, DeleteResult, Doc, Duration, ErrorCode, ExpireResult, FieldDef, FieldType, Fields, Filter, Input, InsertOptions, Ops, Row, Schema, SortSpec, TypeMap, UpdateOps, UpdateOptions, UpdateResult, WatchEvent, WatchOptions, Where, WriteResult };

package/dist/index.js

@@ -13,8 +13,6 @@ var UnauthorizedError = class extends NdbError {
 };
 var NotFoundError = class extends NdbError {
 };
-var VersionConflictError = class extends NdbError {
-};
 var DuplicateIdError = class extends NdbError {
 };
 var UniqueViolationError = class extends NdbError {
@@ -27,13 +25,14 @@ var WatchLaggedError = class extends NdbError {
 };
 var HistoryTruncatedError = class extends NdbError {
 };
+var InvalidUpdateError = class extends NdbError {
+};
 var TtlError = class extends NdbError {
 };
 var subclasses = {
   unauthorized: UnauthorizedError,
   not_found: NotFoundError,
   unknown_collection: NotFoundError,
-  version_conflict: VersionConflictError,
   duplicate_id: DuplicateIdError,
   unique_violation: UniqueViolationError,
   invalid_query: InvalidQueryError,
@@ -44,7 +43,13 @@ var subclasses = {
   watch_lagged: WatchLaggedError,
   history_truncated: HistoryTruncatedError,
   ttl_not_enabled: TtlError,
-  ttl_derived: TtlError
+  ttl_derived: TtlError,
+  unknown_operator: InvalidUpdateError,
+  no_update: InvalidUpdateError,
+  conflicting_update: InvalidUpdateError,
+  invalid_field: InvalidUpdateError,
+  unindexed_many: InvalidUpdateError,
+  empty_filter: InvalidUpdateError
 };
 function makeError(code, message, status = 0) {
   const Cls = subclasses[code] ?? NdbError;
@@ -250,23 +255,35 @@ var Model = class {
   create(docs, opts = {}) {
     return this.insert(docs, opts);
   }
-  async update(id, set, opts = {}) {
+  // Atomic update by filter. The filter and the operators are sent as one
+  // body; the daemon matches and writes in one step on the newest state, so
+  // concurrent updates never interleave. A version guard is a filter:
+  // { call_id: 'c1', _v: 7 }. Matching nothing is not an error: matched is 0.
+  async update(filter, ops, opts = {}) {
     await this.ready();
-    const update = { id, set, unset: opts.unset, if_version: opts.ifVersion, expire_in: opts.expireIn };
-    return this.db.transport.request("POST", this.path("update"), { update });
+    const body = mergeUpdate(filter, ops);
+    const query = writeQuery({ many: opts.many, upsert: opts.upsert, expire_in: opts.expireIn });
+    const out = await this.db.transport.request(
+      "POST",
+      this.path("update") + query,
+      body
+    );
+    return { matched: out.matched, modified: out.modified, doc: out.doc && this.decode(out.doc) };
   }
-  async delete(id, opts = {}) {
+  // Deletes the documents that the filter matches: one, or every match with
+  // many (same rule as update).
+  async delete(filter, opts = {}) {
     await this.ready();
-    await this.db.transport.request("POST", this.path("delete"), { delete: { id, if_version: opts.ifVersion } });
+    return this.db.transport.request("POST", this.path("delete") + writeQuery({ many: opts.many }), toWhere(filter));
   }
   // Makes a document expire, like EXPIRE in Redis: seconds or "30m". It throws
   // NotFoundError for a missing or expired document, and TtlError when the
   // schema has no expires field.
-  expire(id, duration, opts = {}) {
-    return this.setExpiry({ id, in: duration, if_version: opts.ifVersion });
+  expire(id, duration) {
+    return this.setExpiry({ id, in: duration });
   }
-  expireAt(id, at, opts = {}) {
-    return this.setExpiry({ id, at: at.toISOString(), if_version: opts.ifVersion });
+  expireAt(id, at) {
+    return this.setExpiry({ id, at: at.toISOString() });
   }
   // Removes the expiry of a document (PERSIST in Redis).
   async persist(id) {
@@ -378,6 +395,24 @@ var Model = class {
     };
   }
 };
+function writeQuery(params) {
+  const q = new URLSearchParams();
+  for (const [name, value] of Object.entries(params)) {
+    if (value !== void 0 && value !== false) {
+      q.set(name, String(value));
+    }
+  }
+  const text = q.toString();
+  return text === "" ? "" : `?${text}`;
+}
+function mergeUpdate(filter, ops) {
+  for (const key of Object.keys(ops)) {
+    if (!key.startsWith("$")) {
+      throw new InvalidUpdateError("invalid_update", `update operator "${key}" must start with $ (for example "$set")`);
+    }
+  }
+  return { ...toWhere(filter), ...ops };
+}
 
 // src/transport.ts
 import { Pool } from "undici";
@@ -582,6 +617,7 @@ export {
   DuplicateIdError,
   HistoryTruncatedError,
   InvalidQueryError,
+  InvalidUpdateError,
   Model,
   Ndb,
   NdbError,
@@ -590,7 +626,6 @@ export {
   TtlError,
   UnauthorizedError,
   UniqueViolationError,
-  VersionConflictError,
   WatchLaggedError,
   connect,
   makeError

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thadeu/ndb",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "TypeScript client for the ndb daemon",
   "keywords": [
     "ndb",