@lunora/server 1.0.0-alpha.18 → 1.0.0-alpha.19

package/dist/data-model.d.mts

@@ -345,12 +345,24 @@ interface TableWriterFacade<DM, IM extends Record<keyof DM, object>, REL extends
   * {@link TableWriterFacade.hardDelete} to force physical removal.
   */
   delete: (id: Id<string & T>) => Promise<void>;
-  /** Delete many rows in this table by id in one call; returns the *requested* id count (unknown ids are no-ops). Atomic within a mutation (a throw rolls the mutation back); an action has no transaction span. */
-  deleteMany: (ids: ReadonlyArray<Id<string & T>>, options?: {
-    limit?: number;
-  }) => Promise<{
-    deleted: number;
-  }>;
+  /**
+  * Delete many rows in this table. Pass an array of ids (requested count is
+  * returned; unknown ids are no-ops) or `{ where }` to delete matching rows
+  * (actual removed count is returned). Atomic within a mutation.
+  */
+  deleteMany: {
+    (ids: ReadonlyArray<Id<string & T>>, options?: {
+      limit?: number;
+    }): Promise<{
+      deleted: number;
+    }>;
+    (args: {
+      limit?: number;
+      where: Partial<DM[T]>;
+    }): Promise<{
+      deleted: number;
+    }>;
+  };
   /** Physically remove a row (and physically cascade `onDelete`), bypassing `.softDelete()`. Same as `delete()` on a non-soft table. */
   hardDelete: (id: Id<string & T>) => Promise<void>;
   /**
@@ -366,18 +378,44 @@ interface TableWriterFacade<DM, IM extends Record<keyof DM, object>, REL extends
       skipDuplicates?: boolean;
     }): Promise<Id<string & T>>;
   };
-  /** Insert many documents into this table in one call, returning the minted ids in input order. Atomic within a mutation (a throw rolls the mutation back); an action has no transaction span. */
-  insertMany: (values: ReadonlyArray<IM[T]>, options?: {
-    limit?: number;
-  }) => Promise<Id<string & T>[]>;
+  /**
+  * Insert many documents into this table in one call, returning the minted ids
+  * in input order. With `{ skipDuplicates: true }`, UNIQUE breaches resolve to
+  * `null` for that row instead of failing the batch. Atomic within a mutation.
+  */
+  insertMany: {
+    (values: ReadonlyArray<IM[T]>, options: {
+      limit?: number;
+      skipDuplicates: true;
+    }): Promise<(Id<string & T> | null)[]>;
+    (values: ReadonlyArray<IM[T]>, options?: {
+      limit?: number;
+      skipDuplicates?: boolean;
+    }): Promise<Id<string & T>[]>;
+  };
   patch: (id: Id<string & T>, values: Partial<IM[T]>) => Promise<void>;
-  /** Patch many rows in this table by id in one call. Atomic within a mutation (a throw rolls the mutation back); an action has no transaction span. */
-  patchMany: (patches: ReadonlyArray<{
-    id: Id<string & T>;
-    values: Partial<IM[T]>;
-  }>, options?: {
-    limit?: number;
-  }) => Promise<void>;
+  /**
+  * Patch many rows in this table. Pass an array of `{ id, values }` or
+  * `{ where, values }` to patch matching rows with the same values. Returns
+  * the actual patched count. Atomic within a mutation.
+  */
+  patchMany: {
+    (patches: ReadonlyArray<{
+      id: Id<string & T>;
+      values: Partial<IM[T]>;
+    }>, options?: {
+      limit?: number;
+    }): Promise<{
+      patched: number;
+    }>;
+    (args: {
+      limit?: number;
+      values: Partial<IM[T]>;
+      where: Partial<DM[T]>;
+    }): Promise<{
+      patched: number;
+    }>;
+  };
   replace: (id: Id<string & T>, values: IM[T]) => Promise<void>;
   /** Un-soft-delete a row by id: clears the `.softDelete()` marker so list reads see it again. Throws on a non-soft table. */
   restore: (id: Id<string & T>) => Promise<void>;

package/dist/data-model.d.ts

@@ -345,12 +345,24 @@ interface TableWriterFacade<DM, IM extends Record<keyof DM, object>, REL extends
   * {@link TableWriterFacade.hardDelete} to force physical removal.
   */
   delete: (id: Id<string & T>) => Promise<void>;
-  /** Delete many rows in this table by id in one call; returns the *requested* id count (unknown ids are no-ops). Atomic within a mutation (a throw rolls the mutation back); an action has no transaction span. */
-  deleteMany: (ids: ReadonlyArray<Id<string & T>>, options?: {
-    limit?: number;
-  }) => Promise<{
-    deleted: number;
-  }>;
+  /**
+  * Delete many rows in this table. Pass an array of ids (requested count is
+  * returned; unknown ids are no-ops) or `{ where }` to delete matching rows
+  * (actual removed count is returned). Atomic within a mutation.
+  */
+  deleteMany: {
+    (ids: ReadonlyArray<Id<string & T>>, options?: {
+      limit?: number;
+    }): Promise<{
+      deleted: number;
+    }>;
+    (args: {
+      limit?: number;
+      where: Partial<DM[T]>;
+    }): Promise<{
+      deleted: number;
+    }>;
+  };
   /** Physically remove a row (and physically cascade `onDelete`), bypassing `.softDelete()`. Same as `delete()` on a non-soft table. */
   hardDelete: (id: Id<string & T>) => Promise<void>;
   /**
@@ -366,18 +378,44 @@ interface TableWriterFacade<DM, IM extends Record<keyof DM, object>, REL extends
       skipDuplicates?: boolean;
     }): Promise<Id<string & T>>;
   };
-  /** Insert many documents into this table in one call, returning the minted ids in input order. Atomic within a mutation (a throw rolls the mutation back); an action has no transaction span. */
-  insertMany: (values: ReadonlyArray<IM[T]>, options?: {
-    limit?: number;
-  }) => Promise<Id<string & T>[]>;
+  /**
+  * Insert many documents into this table in one call, returning the minted ids
+  * in input order. With `{ skipDuplicates: true }`, UNIQUE breaches resolve to
+  * `null` for that row instead of failing the batch. Atomic within a mutation.
+  */
+  insertMany: {
+    (values: ReadonlyArray<IM[T]>, options: {
+      limit?: number;
+      skipDuplicates: true;
+    }): Promise<(Id<string & T> | null)[]>;
+    (values: ReadonlyArray<IM[T]>, options?: {
+      limit?: number;
+      skipDuplicates?: boolean;
+    }): Promise<Id<string & T>[]>;
+  };
   patch: (id: Id<string & T>, values: Partial<IM[T]>) => Promise<void>;
-  /** Patch many rows in this table by id in one call. Atomic within a mutation (a throw rolls the mutation back); an action has no transaction span. */
-  patchMany: (patches: ReadonlyArray<{
-    id: Id<string & T>;
-    values: Partial<IM[T]>;
-  }>, options?: {
-    limit?: number;
-  }) => Promise<void>;
+  /**
+  * Patch many rows in this table. Pass an array of `{ id, values }` or
+  * `{ where, values }` to patch matching rows with the same values. Returns
+  * the actual patched count. Atomic within a mutation.
+  */
+  patchMany: {
+    (patches: ReadonlyArray<{
+      id: Id<string & T>;
+      values: Partial<IM[T]>;
+    }>, options?: {
+      limit?: number;
+    }): Promise<{
+      patched: number;
+    }>;
+    (args: {
+      limit?: number;
+      values: Partial<IM[T]>;
+      where: Partial<DM[T]>;
+    }): Promise<{
+      patched: number;
+    }>;
+  };
   replace: (id: Id<string & T>, values: IM[T]) => Promise<void>;
   /** Un-soft-delete a row by id: clears the `.softDelete()` marker so list reads see it again. Throws on a non-soft table. */
   restore: (id: Id<string & T>) => Promise<void>;

package/dist/index.d.mts

@@ -299,6 +299,11 @@ interface FacadeWriterLike {
   }, expectedTable?: string): Promise<{
     deleted: number;
   }>;
+  deleteWhere?(tableName: string, where: Record<string, unknown>, options?: {
+    limit?: number;
+  }): Promise<{
+    deleted: number;
+  }>;
   findFirst(tableName: string, args?: unknown): Promise<unknown>;
   findFirstOrThrow(tableName: string, args?: unknown): Promise<unknown>;
   findMany(tableName: string, args?: unknown): Promise<unknown>;
@@ -307,14 +312,25 @@ interface FacadeWriterLike {
   insert(tableName: string, document: Record<string, unknown>): Promise<string>;
   insertMany?(tableName: string, documents: ReadonlyArray<Record<string, unknown>>, options?: {
     limit?: number;
-  }): Promise<string[]>;
+    skipDuplicates?: boolean;
+  }): Promise<(string | null)[]>;
   patch(id: string, patch: Record<string, unknown>, expectedTable?: string): Promise<void>;
   patchMany?(patches: ReadonlyArray<{
     id: string;
     patch: Record<string, unknown>;
   }>, options?: {
     limit?: number;
-  }, expectedTable?: string): Promise<void>;
+  }, expectedTable?: string): Promise<{
+    patched: number;
+  }>;
+  patchWhere?(tableName: string, args: {
+    patch: Record<string, unknown>;
+    where: Record<string, unknown>;
+  }, options?: {
+    limit?: number;
+  }): Promise<{
+    patched: number;
+  }>;
   query(tableName: string): {
     withSearchIndex(indexName: string, search: (q: unknown) => unknown): unknown;
   };
@@ -328,11 +344,19 @@ interface FacadeEntry {
   aggregate: (options: unknown) => Promise<unknown>;
   count: (where?: unknown) => Promise<number>;
   delete: (id: string) => Promise<void>;
-  deleteMany: (ids: ReadonlyArray<string>, options?: {
-    limit?: number;
-  }) => Promise<{
-    deleted: number;
-  }>;
+  deleteMany: {
+    (ids: ReadonlyArray<string>, options?: {
+      limit?: number;
+    }): Promise<{
+      deleted: number;
+    }>;
+    (args: {
+      limit?: number;
+      where: Record<string, unknown>;
+    }): Promise<{
+      deleted: number;
+    }>;
+  };
   /** `true` when at least one row matches `where` (or any row exists when omitted). Honors RLS like `findFirst`. */
   exists: (where?: unknown) => Promise<boolean>;
   findFirst: (args?: unknown) => Promise<unknown>;
@@ -343,16 +367,34 @@ interface FacadeEntry {
   /** Physically remove a row (and physically cascade), bypassing `.softDelete()`. */
   hardDelete: (id: string) => Promise<void>;
   insert: (document: Record<string, unknown>, options?: FacadeInsertOptions) => Promise<null | string>;
+  /**
+  * Insert many documents into this table in one call. With
+  * `{ skipDuplicates: true }`, UNIQUE breaches resolve to `null` for that row
+  * instead of failing the batch. The typed facade narrows the return to
+  * `Id&lt;T>[]` when skipDuplicates is not requested.
+  */
   insertMany: (documents: ReadonlyArray<Record<string, unknown>>, options?: {
     limit?: number;
-  }) => Promise<string[]>;
+    skipDuplicates?: boolean;
+  }) => Promise<(string | null)[]>;
   patch: (id: string, patch: Record<string, unknown>) => Promise<void>;
-  patchMany: (patches: ReadonlyArray<{
-    id: string;
-    values: Record<string, unknown>;
-  }>, options?: {
-    limit?: number;
-  }) => Promise<void>;
+  patchMany: {
+    (patches: ReadonlyArray<{
+      id: string;
+      values: Record<string, unknown>;
+    }>, options?: {
+      limit?: number;
+    }): Promise<{
+      patched: number;
+    }>;
+    (args: {
+      limit?: number;
+      values: Record<string, unknown>;
+      where: Record<string, unknown>;
+    }): Promise<{
+      patched: number;
+    }>;
+  };
   rank: (indexName: string, options: unknown) => Promise<unknown>;
   rankPage: (indexName: string, options?: unknown) => Promise<unknown>;
   replace: (id: string, document: Record<string, unknown>) => Promise<void>;
@@ -843,6 +885,11 @@ interface MaskDatabase {
   }) => Promise<{
     deleted: number;
   }>;
+  deleteWhere?: (tableName: string, where: Record<string, unknown>, options?: {
+    limit?: number;
+  }) => Promise<{
+    deleted: number;
+  }>;
   findFirst: (tableName: string, args?: QueryArgs$1) => Promise<Record<string, unknown> | null>;
   findFirstOrThrow: (tableName: string, args?: QueryArgs$1) => Promise<Record<string, unknown>>;
   findMany: (tableName: string, args?: QueryArgs$1) => Promise<QueryPage$1>;
@@ -854,7 +901,8 @@ interface MaskDatabase {
   insert: (tableName: string, document: Record<string, unknown>) => Promise<string>;
   insertMany: (tableName: string, documents: ReadonlyArray<Record<string, unknown>>, options?: {
     limit?: number;
-  }) => Promise<string[]>;
+    skipDuplicates?: boolean;
+  }) => Promise<(string | null)[]>;
   lookupById?: (id: string, expectedTable?: string) => Promise<null | {
     row: Record<string, unknown>;
     tableName: string;
@@ -865,7 +913,17 @@ interface MaskDatabase {
     patch: Record<string, unknown>;
   }>, options?: {
     limit?: number;
-  }) => Promise<void>;
+  }) => Promise<{
+    patched: number;
+  }>;
+  patchWhere?: (tableName: string, args: {
+    patch: Record<string, unknown>;
+    where: Record<string, unknown>;
+  }, options?: {
+    limit?: number;
+  }) => Promise<{
+    patched: number;
+  }>;
   query: (tableName: string) => TableReaderLike$1;
   rank: (tableName: string, indexName: string, options: unknown) => Promise<null | {
     position: number;
@@ -1737,6 +1795,11 @@ interface DatabaseWriterLike {
   }, expectedTable?: string) => Promise<{
     deleted: number;
   }>;
+  deleteWhere?: (tableName: string, where: WhereInput, options?: {
+    limit?: number;
+  }) => Promise<{
+    deleted: number;
+  }>;
   findFirst: (tableName: string, args?: QueryArgs) => Promise<Record<string, unknown> | null>;
   findFirstOrThrow: (tableName: string, args?: QueryArgs) => Promise<Record<string, unknown>>;
   findMany: (tableName: string, args?: QueryArgs) => Promise<QueryPage>;
@@ -1753,7 +1816,8 @@ interface DatabaseWriterLike {
   insert: (tableName: string, document: Record<string, unknown>) => Promise<string>;
   insertMany: (tableName: string, documents: ReadonlyArray<Record<string, unknown>>, options?: {
     limit?: number;
-  }) => Promise<string[]>;
+    skipDuplicates?: boolean;
+  }) => Promise<(string | null)[]>;
   insertManyUnsafe: (tableName: string, documents: ReadonlyArray<Record<string, unknown>>, options?: {
     allowExplicitId?: boolean;
     limit?: number;
@@ -1776,7 +1840,17 @@ interface DatabaseWriterLike {
     patch: Record<string, unknown>;
   }>, options?: {
     limit?: number;
-  }, expectedTable?: string) => Promise<void>;
+  }, expectedTable?: string) => Promise<{
+    patched: number;
+  }>;
+  patchWhere?: (tableName: string, args: {
+    patch: Record<string, unknown>;
+    where: WhereInput;
+  }, options?: {
+    limit?: number;
+  }) => Promise<{
+    patched: number;
+  }>;
   query: (tableName: string) => TableReaderLike;
   /**
   * Rank a row within its partition. A position is a count-of-rows-before, so

package/dist/index.d.ts

@@ -299,6 +299,11 @@ interface FacadeWriterLike {
   }, expectedTable?: string): Promise<{
     deleted: number;
   }>;
+  deleteWhere?(tableName: string, where: Record<string, unknown>, options?: {
+    limit?: number;
+  }): Promise<{
+    deleted: number;
+  }>;
   findFirst(tableName: string, args?: unknown): Promise<unknown>;
   findFirstOrThrow(tableName: string, args?: unknown): Promise<unknown>;
   findMany(tableName: string, args?: unknown): Promise<unknown>;
@@ -307,14 +312,25 @@ interface FacadeWriterLike {
   insert(tableName: string, document: Record<string, unknown>): Promise<string>;
   insertMany?(tableName: string, documents: ReadonlyArray<Record<string, unknown>>, options?: {
     limit?: number;
-  }): Promise<string[]>;
+    skipDuplicates?: boolean;
+  }): Promise<(string | null)[]>;
   patch(id: string, patch: Record<string, unknown>, expectedTable?: string): Promise<void>;
   patchMany?(patches: ReadonlyArray<{
     id: string;
     patch: Record<string, unknown>;
   }>, options?: {
     limit?: number;
-  }, expectedTable?: string): Promise<void>;
+  }, expectedTable?: string): Promise<{
+    patched: number;
+  }>;
+  patchWhere?(tableName: string, args: {
+    patch: Record<string, unknown>;
+    where: Record<string, unknown>;
+  }, options?: {
+    limit?: number;
+  }): Promise<{
+    patched: number;
+  }>;
   query(tableName: string): {
     withSearchIndex(indexName: string, search: (q: unknown) => unknown): unknown;
   };
@@ -328,11 +344,19 @@ interface FacadeEntry {
   aggregate: (options: unknown) => Promise<unknown>;
   count: (where?: unknown) => Promise<number>;
   delete: (id: string) => Promise<void>;
-  deleteMany: (ids: ReadonlyArray<string>, options?: {
-    limit?: number;
-  }) => Promise<{
-    deleted: number;
-  }>;
+  deleteMany: {
+    (ids: ReadonlyArray<string>, options?: {
+      limit?: number;
+    }): Promise<{
+      deleted: number;
+    }>;
+    (args: {
+      limit?: number;
+      where: Record<string, unknown>;
+    }): Promise<{
+      deleted: number;
+    }>;
+  };
   /** `true` when at least one row matches `where` (or any row exists when omitted). Honors RLS like `findFirst`. */
   exists: (where?: unknown) => Promise<boolean>;
   findFirst: (args?: unknown) => Promise<unknown>;
@@ -343,16 +367,34 @@ interface FacadeEntry {
   /** Physically remove a row (and physically cascade), bypassing `.softDelete()`. */
   hardDelete: (id: string) => Promise<void>;
   insert: (document: Record<string, unknown>, options?: FacadeInsertOptions) => Promise<null | string>;
+  /**
+  * Insert many documents into this table in one call. With
+  * `{ skipDuplicates: true }`, UNIQUE breaches resolve to `null` for that row
+  * instead of failing the batch. The typed facade narrows the return to
+  * `Id&lt;T>[]` when skipDuplicates is not requested.
+  */
   insertMany: (documents: ReadonlyArray<Record<string, unknown>>, options?: {
     limit?: number;
-  }) => Promise<string[]>;
+    skipDuplicates?: boolean;
+  }) => Promise<(string | null)[]>;
   patch: (id: string, patch: Record<string, unknown>) => Promise<void>;
-  patchMany: (patches: ReadonlyArray<{
-    id: string;
-    values: Record<string, unknown>;
-  }>, options?: {
-    limit?: number;
-  }) => Promise<void>;
+  patchMany: {
+    (patches: ReadonlyArray<{
+      id: string;
+      values: Record<string, unknown>;
+    }>, options?: {
+      limit?: number;
+    }): Promise<{
+      patched: number;
+    }>;
+    (args: {
+      limit?: number;
+      values: Record<string, unknown>;
+      where: Record<string, unknown>;
+    }): Promise<{
+      patched: number;
+    }>;
+  };
   rank: (indexName: string, options: unknown) => Promise<unknown>;
   rankPage: (indexName: string, options?: unknown) => Promise<unknown>;
   replace: (id: string, document: Record<string, unknown>) => Promise<void>;
@@ -843,6 +885,11 @@ interface MaskDatabase {
   }) => Promise<{
     deleted: number;
   }>;
+  deleteWhere?: (tableName: string, where: Record<string, unknown>, options?: {
+    limit?: number;
+  }) => Promise<{
+    deleted: number;
+  }>;
   findFirst: (tableName: string, args?: QueryArgs$1) => Promise<Record<string, unknown> | null>;
   findFirstOrThrow: (tableName: string, args?: QueryArgs$1) => Promise<Record<string, unknown>>;
   findMany: (tableName: string, args?: QueryArgs$1) => Promise<QueryPage$1>;
@@ -854,7 +901,8 @@ interface MaskDatabase {
   insert: (tableName: string, document: Record<string, unknown>) => Promise<string>;
   insertMany: (tableName: string, documents: ReadonlyArray<Record<string, unknown>>, options?: {
     limit?: number;
-  }) => Promise<string[]>;
+    skipDuplicates?: boolean;
+  }) => Promise<(string | null)[]>;
   lookupById?: (id: string, expectedTable?: string) => Promise<null | {
     row: Record<string, unknown>;
     tableName: string;
@@ -865,7 +913,17 @@ interface MaskDatabase {
     patch: Record<string, unknown>;
   }>, options?: {
     limit?: number;
-  }) => Promise<void>;
+  }) => Promise<{
+    patched: number;
+  }>;
+  patchWhere?: (tableName: string, args: {
+    patch: Record<string, unknown>;
+    where: Record<string, unknown>;
+  }, options?: {
+    limit?: number;
+  }) => Promise<{
+    patched: number;
+  }>;
   query: (tableName: string) => TableReaderLike$1;
   rank: (tableName: string, indexName: string, options: unknown) => Promise<null | {
     position: number;
@@ -1737,6 +1795,11 @@ interface DatabaseWriterLike {
   }, expectedTable?: string) => Promise<{
     deleted: number;
   }>;
+  deleteWhere?: (tableName: string, where: WhereInput, options?: {
+    limit?: number;
+  }) => Promise<{
+    deleted: number;
+  }>;
   findFirst: (tableName: string, args?: QueryArgs) => Promise<Record<string, unknown> | null>;
   findFirstOrThrow: (tableName: string, args?: QueryArgs) => Promise<Record<string, unknown>>;
   findMany: (tableName: string, args?: QueryArgs) => Promise<QueryPage>;
@@ -1753,7 +1816,8 @@ interface DatabaseWriterLike {
   insert: (tableName: string, document: Record<string, unknown>) => Promise<string>;
   insertMany: (tableName: string, documents: ReadonlyArray<Record<string, unknown>>, options?: {
     limit?: number;
-  }) => Promise<string[]>;
+    skipDuplicates?: boolean;
+  }) => Promise<(string | null)[]>;
   insertManyUnsafe: (tableName: string, documents: ReadonlyArray<Record<string, unknown>>, options?: {
     allowExplicitId?: boolean;
     limit?: number;
@@ -1776,7 +1840,17 @@ interface DatabaseWriterLike {
     patch: Record<string, unknown>;
   }>, options?: {
     limit?: number;
-  }, expectedTable?: string) => Promise<void>;
+  }, expectedTable?: string) => Promise<{
+    patched: number;
+  }>;
+  patchWhere?: (tableName: string, args: {
+    patch: Record<string, unknown>;
+    where: WhereInput;
+  }, options?: {
+    limit?: number;
+  }) => Promise<{
+    patched: number;
+  }>;
   query: (tableName: string) => TableReaderLike;
   /**
   * Rank a row within its partition. A position is a count-of-rows-before, so

package/dist/index.mjs

@@ -3,7 +3,7 @@ export { initLunora } from './packem_shared/initLunora-sQUqaejx.mjs';
 export { createSecrets } from './packem_shared/createSecrets-DwaR2rNG.mjs';
 export { LunoraEnvError, defineEnv, redactSecrets } from './packem_shared/LunoraEnvError-BGmd1Qs0.mjs';
 export { LunoraError } from './packem_shared/LunoraError-WbxmrpxR.mjs';
-export { bindOrm, bindTableFacade } from './packem_shared/bindOrm-CNXKgfUa.mjs';
+export { bindOrm, bindTableFacade } from './packem_shared/bindOrm-Bfgl7f-Q.mjs';
 export { httpAction, httpRoute, httpRouter, isSafeHeaderValue, serveStorageObject } from './packem_shared/httpAction-DCXoYPIk.mjs';
 export { defineIdentity } from './packem_shared/defineIdentity-DiX4zM9x.mjs';
 export { onConnect, onDisconnect } from './packem_shared/onConnect-CIPXKPyw.mjs';
@@ -17,11 +17,11 @@ export { defineShape } from './packem_shared/defineShape-C5scNOrf.mjs';
 export { anyApi } from './types.mjs';
 export { cronJobs } from '@lunora/scheduler';
 export { ValidationError, v } from '@lunora/values';
-export { buildRlsReadRegistry, composeShapeReadWhere } from './packem_shared/buildRlsReadRegistry-DFBFLydB.mjs';
+export { buildRlsReadRegistry, composeShapeReadWhere } from './packem_shared/buildRlsReadRegistry-D54vUQe4.mjs';
 export { createPolicyDsl, definePermission, definePolicies, definePolicy, defineRole } from './packem_shared/createPolicyDsl-By3QB4he.mjs';
 export { defineStorageRule, defineStorageRules } from './packem_shared/defineStorageRule-B5nL4Z1P.mjs';
-export { mask } from './packem_shared/mask-Dc8G5Gl7.mjs';
-export { rls } from './packem_shared/rls-3sCJIH6F.mjs';
+export { mask } from './packem_shared/mask-BT1YgRbF.mjs';
+export { rls } from './packem_shared/rls-B_ZWgslr.mjs';
 export { storageRules } from './packem_shared/storageRules-6QxzDOcx.mjs';
 
 const VERSION = "0.0.0";

package/dist/packem_shared/{bindOrm-CNXKgfUa.mjs → bindOrm-Bfgl7f-Q.mjs}

@@ -44,15 +44,24 @@ const bindTableFacade = (writer, tableName) => {
     count: (where) => writer.count(tableName, where),
     delete: (id) => writer.delete(id, tableName),
     // `deleteMany`/`patchMany` forward the bound `tableName` as `expectedTable`
-    // (threaded through the writer + the RLS middleware's per-id gate) so every
-    // batched id is scoped to this table — the same IDOR guard the single-row
-    // `delete`/`patch` apply. `patchMany` maps the facade's `values` payload to
-    // the writer's `{ id, patch }` shape.
-    deleteMany: (ids, options) => {
-      if (writer.deleteMany === void 0) {
-        throw new LunoraError$1("INTERNAL", `ctx.db.${tableName}.deleteMany is unavailable: this writer has no batch delete`);
+    // for id-based calls (threaded through the writer + the RLS middleware's
+    // per-id gate) so every batched id is scoped to this table — the same IDOR
+    // guard the single-row `delete`/`patch` apply. The where-based form routes
+    // through the structural writer's `deleteMany(tableName, { where })`.
+    // `patchMany` maps the facade's `values` payload to the writer's
+    // `{ id, patch }` shape.
+    deleteMany: (first, options) => {
+      if (Array.isArray(first)) {
+        if (writer.deleteMany === void 0) {
+          throw new LunoraError$1("INTERNAL", `ctx.db.${tableName}.deleteMany is unavailable: this writer has no batch delete`);
+        }
+        return writer.deleteMany(first, options, tableName);
       }
-      return writer.deleteMany(ids, options, tableName);
+      if (writer.deleteWhere === void 0) {
+        throw new LunoraError$1("INTERNAL", `ctx.db.${tableName}.deleteMany({ where }) is unavailable: this writer has no where-based delete`);
+      }
+      const whereArgs = first;
+      return writer.deleteWhere(tableName, whereArgs.where, { limit: whereArgs.limit });
     },
     // `exists` reuses `findFirst` (RLS-filtered, indexed when a `.withIndex`-able
     // `where` is supplied) and only asks whether a row came back — no count scan.
@@ -72,17 +81,24 @@ const bindTableFacade = (writer, tableName) => {
       return writer.insertMany(tableName, documents, options);
     },
     patch: (id, patch) => writer.patch(id, patch, tableName),
-    patchMany: (patches, options) => {
-      if (writer.patchMany === void 0) {
-        throw new LunoraError$1("INTERNAL", `ctx.db.${tableName}.patchMany is unavailable: this writer has no batch patch`);
+    patchMany: (first, options) => {
+      if (Array.isArray(first)) {
+        if (writer.patchMany === void 0) {
+          throw new LunoraError$1("INTERNAL", `ctx.db.${tableName}.patchMany is unavailable: this writer has no batch patch`);
+        }
+        return writer.patchMany(
+          first.map((entry) => {
+            return { id: entry.id, patch: entry.values };
+          }),
+          options,
+          tableName
+        );
+      }
+      if (writer.patchWhere === void 0) {
+        throw new LunoraError$1("INTERNAL", `ctx.db.${tableName}.patchMany({ where, values }) is unavailable: this writer has no where-based patch`);
       }
-      return writer.patchMany(
-        patches.map((entry) => {
-          return { id: entry.id, patch: entry.values };
-        }),
-        options,
-        tableName
-      );
+      const whereArgs = first;
+      return writer.patchWhere(tableName, { patch: whereArgs.values, where: whereArgs.where }, { limit: whereArgs.limit });
     },
     rank: (indexName, options) => writer.rank(tableName, indexName, options),
     rankPage: (indexName, options) => writer.rankPage(tableName, indexName, options),

package/dist/packem_shared/{buildRlsReadRegistry-DFBFLydB.mjs → buildRlsReadRegistry-D54vUQe4.mjs}

@@ -1,4 +1,4 @@
-import { indexRolePermissions, computeReadBaseWhere, permissionName } from './rls-3sCJIH6F.mjs';
+import { indexRolePermissions, computeReadBaseWhere, permissionName } from './rls-B_ZWgslr.mjs';
 import { r as readRlsTag } from './policy-tag-DvpVH2tv.mjs';
 
 const FALSE_PREDICATE = { OR: [] };

package/dist/packem_shared/{mask-Dc8G5Gl7.mjs → mask-BT1YgRbF.mjs}

@@ -1,5 +1,5 @@
 import { LunoraError } from './LunoraError-WbxmrpxR.mjs';
-import { bindTableFacade, bindOrm } from './bindOrm-CNXKgfUa.mjs';
+import { bindTableFacade, bindOrm } from './bindOrm-Bfgl7f-Q.mjs';
 
 const permissionName = (permission) => typeof permission === "string" ? permission : permission.name;
 const indexRolePermissions = (roles) => {

package/dist/packem_shared/{rls-3sCJIH6F.mjs → rls-B_ZWgslr.mjs}

@@ -1,5 +1,5 @@
 import { LunoraError } from './LunoraError-WbxmrpxR.mjs';
-import { bindTableFacade, bindOrm } from './bindOrm-CNXKgfUa.mjs';
+import { bindTableFacade, bindOrm } from './bindOrm-Bfgl7f-Q.mjs';
 import { t as tagRlsMiddleware } from './policy-tag-DvpVH2tv.mjs';
 
 const DEFAULT_BATCH_LIMIT = 500;
@@ -333,6 +333,16 @@ const wrapDatabase = (base, raw, perTable, context) => {
       }
       return { deleted: ids.length };
     },
+    async deleteWhere(tableName, where, options) {
+      const { baseWhere } = readBase(tableName);
+      const resolved = await route(tableName).findMany(tableName, {
+        baseWhere: mergeBaseWhere(where, baseWhere),
+        relationBaseWhere: relationReadFilter
+      });
+      const ids = resolved.page.map((row) => String(row["_id"]));
+      assertBatchLimit(ids.length, options?.limit, "deleteWhere");
+      return wrapped.deleteMany(ids, options);
+    },
     async findFirst(tableName, args) {
       const { baseWhere } = readBase(tableName);
       return route(tableName).findFirst(tableName, {
@@ -436,6 +446,19 @@ const wrapDatabase = (base, raw, perTable, context) => {
           expectedTable
         );
       }
+      return { patched: patches.length };
+    },
+    async patchWhere(tableName, args, options) {
+      const { baseWhere } = readBase(tableName);
+      const resolved = await route(tableName).findMany(tableName, {
+        baseWhere: mergeBaseWhere(args.where, baseWhere),
+        relationBaseWhere: relationReadFilter
+      });
+      const patches = resolved.page.map((row) => {
+        return { id: String(row["_id"]), patch: args.patch };
+      });
+      assertBatchLimit(patches.length, options?.limit, "patchWhere");
+      return wrapped.patchMany(patches, options);
     },
     query(tableName) {
       const { baseWhere } = readBase(tableName);

package/dist/rls/testing.mjs

@@ -1,4 +1,4 @@
-import { indexRolePermissions, computeReadBaseWhere, matchesWhere, evaluateWrite, permissionName } from '../packem_shared/rls-3sCJIH6F.mjs';
+import { indexRolePermissions, computeReadBaseWhere, matchesWhere, evaluateWrite, permissionName } from '../packem_shared/rls-B_ZWgslr.mjs';
 
 const expectPolicy = (policies, options = {}) => {
   const rolePermissions = indexRolePermissions(options.roles);

package/dist/types.d.mts

@@ -518,6 +518,16 @@ interface BatchWriteOptions {
   /** Reject the call when the batch size exceeds this value (default 500). */
   limit?: number;
 }
+/** Options accepted by {@link DatabaseWriter.insertMany} and the per-table facade. */
+interface InsertManyOptions extends BatchWriteOptions {
+  /**
+  * When `true`, a UNIQUE-constraint breach for a row resolves to `null`
+  * instead of throwing — the rest of the batch is still inserted. Skipped rows
+  * keep their input-order slot with `null` in the returned array. Mirrors
+  * better-drizzle's `createMany({ skipDuplicates: true })`.
+  */
+  skipDuplicates?: boolean;
+}
 interface DatabaseWriter extends DatabaseReader {
   delete: <T extends string>(id: Id<T>) => Promise<void>;
   /**
@@ -535,6 +545,18 @@ interface DatabaseWriter extends DatabaseReader {
     deleted: number;
   }>;
   /**
+  * Delete every row matching `where` in one call. Matching rows are resolved
+  * first, then each row is deleted through the single-row delete pipeline
+  * (triggers, companion sync, CDC, broadcast) so reactive subscriptions and
+  * search/aggregate companions stay correct.
+  *
+  * **Atomic within a mutation:** the DO wraps a mutation's dispatch in a
+  * BEGIN/COMMIT span, so a mid-batch failure rolls back the whole mutation.
+  */
+  deleteWhere: (tableName: string, where: Record<string, unknown>, options?: BatchWriteOptions) => Promise<{
+    deleted: number;
+  }>;
+  /**
   * Insert a document, returning its server id.
   *
   * Pass `options.clientId` (a UUID) to key the row yourself — for an
@@ -551,12 +573,21 @@ interface DatabaseWriter extends DatabaseReader {
   * row gets defaults, validators, triggers, and a per-row RLS check — but the
   * caller pays one round-trip instead of N.
   *
+  * Pass `{ skipDuplicates: true }` to turn UNIQUE-constraint breaches into
+  * `null` results for that row instead of failing the whole batch; the rest of
+  * the batch is still inserted and order is preserved.
+  *
   * **Atomic within a mutation:** the DO wraps a mutation's dispatch in a
   * BEGIN/COMMIT span, so a mid-batch failure (an invalid or RLS-denied row)
   * rolls back the whole mutation. (In an action there is no transaction span,
   * so the prior inserts persist; the in-memory test harness mirrors the span.)
   */
-  insertMany: <T extends string>(tableName: T, documents: ReadonlyArray<Record<string, unknown>>, options?: BatchWriteOptions) => Promise<Id<T>[]>;
+  insertMany: {
+    <T extends string>(tableName: T, documents: ReadonlyArray<Record<string, unknown>>, options: BatchWriteOptions & {
+      skipDuplicates: true;
+    }): Promise<(Id<T> | null)[]>;
+    <T extends string>(tableName: T, documents: ReadonlyArray<Record<string, unknown>>, options?: InsertManyOptions): Promise<Id<T>[]>;
+  };
   /**
   * **Trusted** bulk insert: one multi-row `INSERT` that **skips per-row
   * `.check()` validators and before/after triggers** for throughput on data you
@@ -576,7 +607,8 @@ interface DatabaseWriter extends DatabaseReader {
   patch: <T extends string>(id: Id<T>, patch: Record<string, unknown>) => Promise<void>;
   /**
   * Patch many rows by id in one call. Each `{ id, patch }` is applied like a
-  * single `patch()` (per-row triggers + RLS).
+  * single `patch()` (per-row triggers + RLS). Returns the number of rows
+  * actually patched.
   *
   * **Atomic within a mutation:** the DO wraps a mutation's dispatch in a
   * BEGIN/COMMIT span, so a mid-batch failure rolls back the whole mutation.
@@ -586,7 +618,24 @@ interface DatabaseWriter extends DatabaseReader {
   patchMany: <T extends string>(patches: ReadonlyArray<{
     id: Id<T>;
     patch: Record<string, unknown>;
-  }>, options?: BatchWriteOptions) => Promise<void>;
+  }>, options?: BatchWriteOptions) => Promise<{
+    patched: number;
+  }>;
+  /**
+  * Patch every row matching `where` with the same `patch` in one call. The
+  * matching rows are resolved first, then each row is updated through the
+  * single-row patch pipeline (OCC, triggers, companion sync, CDC, broadcast)
+  * so reactive subscriptions and search/aggregate companions stay correct.
+  *
+  * **Atomic within a mutation:** the DO wraps a mutation's dispatch in a
+  * BEGIN/COMMIT span, so a mid-batch failure rolls back the whole mutation.
+  */
+  patchWhere: (tableName: string, args: {
+    patch: Record<string, unknown>;
+    where: Record<string, unknown>;
+  }, options?: BatchWriteOptions) => Promise<{
+    patched: number;
+  }>;
   replace: <T extends string>(id: Id<T>, document: Record<string, unknown>) => Promise<void>;
 }
 /** Authenticated identity surfaced into every context. */

package/dist/types.d.ts

@@ -518,6 +518,16 @@ interface BatchWriteOptions {
   /** Reject the call when the batch size exceeds this value (default 500). */
   limit?: number;
 }
+/** Options accepted by {@link DatabaseWriter.insertMany} and the per-table facade. */
+interface InsertManyOptions extends BatchWriteOptions {
+  /**
+  * When `true`, a UNIQUE-constraint breach for a row resolves to `null`
+  * instead of throwing — the rest of the batch is still inserted. Skipped rows
+  * keep their input-order slot with `null` in the returned array. Mirrors
+  * better-drizzle's `createMany({ skipDuplicates: true })`.
+  */
+  skipDuplicates?: boolean;
+}
 interface DatabaseWriter extends DatabaseReader {
   delete: <T extends string>(id: Id<T>) => Promise<void>;
   /**
@@ -535,6 +545,18 @@ interface DatabaseWriter extends DatabaseReader {
     deleted: number;
   }>;
   /**
+  * Delete every row matching `where` in one call. Matching rows are resolved
+  * first, then each row is deleted through the single-row delete pipeline
+  * (triggers, companion sync, CDC, broadcast) so reactive subscriptions and
+  * search/aggregate companions stay correct.
+  *
+  * **Atomic within a mutation:** the DO wraps a mutation's dispatch in a
+  * BEGIN/COMMIT span, so a mid-batch failure rolls back the whole mutation.
+  */
+  deleteWhere: (tableName: string, where: Record<string, unknown>, options?: BatchWriteOptions) => Promise<{
+    deleted: number;
+  }>;
+  /**
   * Insert a document, returning its server id.
   *
   * Pass `options.clientId` (a UUID) to key the row yourself — for an
@@ -551,12 +573,21 @@ interface DatabaseWriter extends DatabaseReader {
   * row gets defaults, validators, triggers, and a per-row RLS check — but the
   * caller pays one round-trip instead of N.
   *
+  * Pass `{ skipDuplicates: true }` to turn UNIQUE-constraint breaches into
+  * `null` results for that row instead of failing the whole batch; the rest of
+  * the batch is still inserted and order is preserved.
+  *
   * **Atomic within a mutation:** the DO wraps a mutation's dispatch in a
   * BEGIN/COMMIT span, so a mid-batch failure (an invalid or RLS-denied row)
   * rolls back the whole mutation. (In an action there is no transaction span,
   * so the prior inserts persist; the in-memory test harness mirrors the span.)
   */
-  insertMany: <T extends string>(tableName: T, documents: ReadonlyArray<Record<string, unknown>>, options?: BatchWriteOptions) => Promise<Id<T>[]>;
+  insertMany: {
+    <T extends string>(tableName: T, documents: ReadonlyArray<Record<string, unknown>>, options: BatchWriteOptions & {
+      skipDuplicates: true;
+    }): Promise<(Id<T> | null)[]>;
+    <T extends string>(tableName: T, documents: ReadonlyArray<Record<string, unknown>>, options?: InsertManyOptions): Promise<Id<T>[]>;
+  };
   /**
   * **Trusted** bulk insert: one multi-row `INSERT` that **skips per-row
   * `.check()` validators and before/after triggers** for throughput on data you
@@ -576,7 +607,8 @@ interface DatabaseWriter extends DatabaseReader {
   patch: <T extends string>(id: Id<T>, patch: Record<string, unknown>) => Promise<void>;
   /**
   * Patch many rows by id in one call. Each `{ id, patch }` is applied like a
-  * single `patch()` (per-row triggers + RLS).
+  * single `patch()` (per-row triggers + RLS). Returns the number of rows
+  * actually patched.
   *
   * **Atomic within a mutation:** the DO wraps a mutation's dispatch in a
   * BEGIN/COMMIT span, so a mid-batch failure rolls back the whole mutation.
@@ -586,7 +618,24 @@ interface DatabaseWriter extends DatabaseReader {
   patchMany: <T extends string>(patches: ReadonlyArray<{
     id: Id<T>;
     patch: Record<string, unknown>;
-  }>, options?: BatchWriteOptions) => Promise<void>;
+  }>, options?: BatchWriteOptions) => Promise<{
+    patched: number;
+  }>;
+  /**
+  * Patch every row matching `where` with the same `patch` in one call. The
+  * matching rows are resolved first, then each row is updated through the
+  * single-row patch pipeline (OCC, triggers, companion sync, CDC, broadcast)
+  * so reactive subscriptions and search/aggregate companions stay correct.
+  *
+  * **Atomic within a mutation:** the DO wraps a mutation's dispatch in a
+  * BEGIN/COMMIT span, so a mid-batch failure rolls back the whole mutation.
+  */
+  patchWhere: (tableName: string, args: {
+    patch: Record<string, unknown>;
+    where: Record<string, unknown>;
+  }, options?: BatchWriteOptions) => Promise<{
+    patched: number;
+  }>;
   replace: <T extends string>(id: Id<T>, document: Record<string, unknown>) => Promise<void>;
 }
 /** Authenticated identity surfaced into every context. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/server",
-  "version": "1.0.0-alpha.18",
+  "version": "1.0.0-alpha.19",
   "description": "Server primitives for Lunora: defineSchema, defineTable, query, mutation, and action",
   "keywords": [
     "backend",