@lunora/do 1.0.0-alpha.23 → 1.0.0-alpha.25

package/LICENSE.md

@@ -103,3 +103,9 @@ Unless required by applicable law or agreed to in writing, software distributed
 under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 CONDITIONS OF ANY KIND, either express or implied. See the License for the
 specific language governing permissions and limitations under the License.
+
+<!-- DEPENDENCIES -->
+<!-- /DEPENDENCIES -->
+
+<!-- TYPE_DEPENDENCIES -->
+<!-- /TYPE_DEPENDENCIES -->

package/dist/index.d.mts

@@ -1679,6 +1679,18 @@ interface DatabaseWriterLike {
   }, expectedTable?: string) => Promise<{
     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 so
+  * companions, CDC, and broadcast stay correct. **Atomic within a mutation** —
+  * the DO wraps a mutation's dispatch in a BEGIN/COMMIT span, so a mid-batch
+  * throw rolls the whole mutation back. (An action has no transaction span.)
+  */
+  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>;
@@ -1714,11 +1726,13 @@ interface DatabaseWriterLike {
   * Insert many documents into one table (a loop over `insert()`),
   * returning the minted ids in input order. Each row gets defaults,
   * validators, triggers, companion sync, CDC, and broadcast exactly as a
-  * single insert; the caller pays one round-trip instead of N. **Atomic within
-  * a mutation** — the DO wraps a mutation's dispatch in a BEGIN/COMMIT span, so
-  * a mid-batch throw rolls the whole mutation back. (An action has no
-  * transaction span — there, the prior inserts persist; the in-memory test
-  * harness mirrors the span.)
+  * single insert; the caller pays one round-trip instead of N. Pass
+  * `options.skipDuplicates: true` to turn UNIQUE-constraint breaches into
+  * `null` results for that row instead of failing the whole batch.
+  * **Atomic within a mutation** — the DO wraps a mutation's dispatch in a
+  * BEGIN/COMMIT span, so a mid-batch throw rolls the whole mutation back. (An
+  * action has no transaction span — there, the prior inserts persist; the
+  * in-memory test harness mirrors the span.)
   * Rejects a batch larger than `options.limit` (default {@link DEFAULT_BATCH_LIMIT}).
   *
   * Optional on the interface (like `rankBefore`): the DO writer implements it;
@@ -1728,7 +1742,8 @@ interface DatabaseWriterLike {
   */
   insertMany?: (tableName: string, documents: ReadonlyArray<Record<string, unknown>>, options?: {
     limit?: number;
-  }) => Promise<string[]>;
+    skipDuplicates?: boolean;
+  }) => Promise<(string | null)[]>;
   /**
   * Trusted bulk insert: one multi-row `INSERT` that **skips per-row `.check()`
   * validators and before/after triggers** for throughput on data the caller
@@ -1783,7 +1798,25 @@ interface DatabaseWriterLike {
     patch: Record<string, unknown>;
   }>, options?: {
     limit?: number;
-  }, expectedTable?: string) => Promise<void>;
+  }, expectedTable?: string) => Promise<{
+    patched: number;
+  }>;
+  /**
+  * Patch every row matching `where` with the same `patch` in one call.
+  * Matching rows are resolved first, then each row is patched through the
+  * single-row patch pipeline so companions, CDC, and broadcast stay correct.
+  * **Atomic within a mutation** — the DO wraps a mutation's dispatch in a
+  * BEGIN/COMMIT span, so a mid-batch throw rolls the whole mutation back. (An
+  * action has no transaction span.)
+  */
+  patchWhere?: (tableName: string, args: {
+    patch: Record<string, unknown>;
+    where: WhereInput;
+  }, options?: {
+    limit?: number;
+  }) => Promise<{
+    patched: number;
+  }>;
   query: (tableName: string) => TableReaderLike;
   /**
   * Return the 1-based position of `options.row` within its partition under
@@ -3806,43 +3839,6 @@ declare const MIN_AUTH_SECRET_LENGTH = 32;
 * a *missing* token is never itself a finding here (introspection is simply off).
 */
 declare const buildSecurityAudit: (rawEnv: unknown) => SecurityAuditResult;
-/**
-* Durable Object that owns auth session state.
-*
-* `@lunora/auth` used to write sessions directly into D1 alongside user
-* records. That worked but coupled session lifecycle to a global database —
-* every read had to cross the region, every write contended with user
-* inserts. SessionDO owns sessions in a DO-local KV store: same-prefix
-* tokens co-locate (via `idFromName(token.slice(0, 16))`) so the DO instance
-* count stays bounded; reads and writes never round-trip to D1.
-*
-* Wire shape: HTTP only, never RPC. The auth package calls
-*
-* `await env.SESSION.get(env.SESSION.idFromName(prefix)).fetch(...)`
-*
-* with one of:
-*
-* POST   /create   body: { token, userId, ttlSeconds }
-* GET    /get      header: `x-lunora-session-token: &lt;token>`
-* DELETE /revoke   header: `x-lunora-session-token: &lt;token>`
-*
-* Every request must additionally carry an `x-lunora-session-secret` header
-* whose value matches `env.SESSION_DO_SECRET`. The DO is reachable from any
-* worker bound to its namespace, so a shared secret is the only thing that
-* prevents a compromised or misbehaving worker from reading arbitrary
-* sessions — the binding alone is not an auth surface.
-*
-* The DO returns JSON bodies that `@lunora/auth` reshapes into its public
-* `AuthSession` type. Keep the surface narrow — anything more elaborate
-* should ride on top via a wrapper, not by widening this contract.
-*
-* # Subclassing
-*
-* Apps subclass `SessionDO` (or use the codegen subclass) and register the
-* subclass in `wrangler.jsonc` as `SESSION`. The platform DO binding requires
-* a concrete `DurableObject` class today; the structural state shape used by
-* the unit tests is preserved so plain-object doubles still work.
-*/
 /** Default TTL for new sessions (7 days), matching `@lunora/auth`. */
 declare const SESSION_DO_TTL_DEFAULT: number;
 /** Hard ceiling on the requested TTL — 90 days. Longer sessions should ride on top via refresh. */
@@ -6453,42 +6449,6 @@ declare abstract class ShardDO {
   private deliverWhisperLocal;
   private readAttachment;
 }
-/**
-* Durable Object that owns the live set of shard keys per sharded table.
-*
-* The query coordinator (`@lunora/runtime`) fans out cross-shard reads to
-* every live shard. With the static registry, the app supplies the shard
-* key list at boot — which is fine for fixed-cardinality deployments
-* (a known set of tenants) and unworkable for dynamic ones (one shard per
-* user-created channel, organisation, project, …).
-*
-* `ShardRegistryDO` is the persistent source of truth. A worker:
-*
-* - calls `POST /register {table, shardKey}` when a sharded table first
-* sees a write on a new key (typically from `ctx.db.&lt;table>.insert` via
-* the worker's onWrite hook, fired through `ctx.waitUntil` so the
-* user-facing write doesn't pay the registry round-trip);
-* - calls `POST /unregister {table, shardKey}` when a shard is decommissioned;
-* - calls `GET /list?table=X` to materialise the fan-out target list. The
-* client (`createDynamicShardRegistry` in `@lunora/runtime`) caches the
-* answer with a small TTL so a wide fan-out doesn't pay a registry
-* round-trip on every call.
-*
-* Single-instance contract: deploy one DO instance per environment, by
-* convention named {@link SHARD_REGISTRY_DO_NAME}. The DO is small (just a
-* `Map&lt;table, Set&lt;shardKey>>`) and writes are infrequent (only on first-seen
-* shardKey per table), so a single instance is sufficient up to tens of
-* thousands of distinct shard keys.
-*
-* Wire shape: HTTP only, never RPC.
-*
-* POST /register   body: { table, shardKey }
-* POST /unregister body: { table, shardKey }
-* GET  /list?table=...
-* GET  /snapshot                (debug: returns the full table → [keys] map)
-*
-* Responses are JSON; the client shapes them. Keep the surface narrow.
-*/
 /** Conventional DO instance name, passed to `idFromName` to address the single registry instance. */
 declare const SHARD_REGISTRY_DO_NAME: string;
 /**

package/dist/index.d.ts

@@ -1679,6 +1679,18 @@ interface DatabaseWriterLike {
   }, expectedTable?: string) => Promise<{
     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 so
+  * companions, CDC, and broadcast stay correct. **Atomic within a mutation** —
+  * the DO wraps a mutation's dispatch in a BEGIN/COMMIT span, so a mid-batch
+  * throw rolls the whole mutation back. (An action has no transaction span.)
+  */
+  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>;
@@ -1714,11 +1726,13 @@ interface DatabaseWriterLike {
   * Insert many documents into one table (a loop over `insert()`),
   * returning the minted ids in input order. Each row gets defaults,
   * validators, triggers, companion sync, CDC, and broadcast exactly as a
-  * single insert; the caller pays one round-trip instead of N. **Atomic within
-  * a mutation** — the DO wraps a mutation's dispatch in a BEGIN/COMMIT span, so
-  * a mid-batch throw rolls the whole mutation back. (An action has no
-  * transaction span — there, the prior inserts persist; the in-memory test
-  * harness mirrors the span.)
+  * single insert; the caller pays one round-trip instead of N. Pass
+  * `options.skipDuplicates: true` to turn UNIQUE-constraint breaches into
+  * `null` results for that row instead of failing the whole batch.
+  * **Atomic within a mutation** — the DO wraps a mutation's dispatch in a
+  * BEGIN/COMMIT span, so a mid-batch throw rolls the whole mutation back. (An
+  * action has no transaction span — there, the prior inserts persist; the
+  * in-memory test harness mirrors the span.)
   * Rejects a batch larger than `options.limit` (default {@link DEFAULT_BATCH_LIMIT}).
   *
   * Optional on the interface (like `rankBefore`): the DO writer implements it;
@@ -1728,7 +1742,8 @@ interface DatabaseWriterLike {
   */
   insertMany?: (tableName: string, documents: ReadonlyArray<Record<string, unknown>>, options?: {
     limit?: number;
-  }) => Promise<string[]>;
+    skipDuplicates?: boolean;
+  }) => Promise<(string | null)[]>;
   /**
   * Trusted bulk insert: one multi-row `INSERT` that **skips per-row `.check()`
   * validators and before/after triggers** for throughput on data the caller
@@ -1783,7 +1798,25 @@ interface DatabaseWriterLike {
     patch: Record<string, unknown>;
   }>, options?: {
     limit?: number;
-  }, expectedTable?: string) => Promise<void>;
+  }, expectedTable?: string) => Promise<{
+    patched: number;
+  }>;
+  /**
+  * Patch every row matching `where` with the same `patch` in one call.
+  * Matching rows are resolved first, then each row is patched through the
+  * single-row patch pipeline so companions, CDC, and broadcast stay correct.
+  * **Atomic within a mutation** — the DO wraps a mutation's dispatch in a
+  * BEGIN/COMMIT span, so a mid-batch throw rolls the whole mutation back. (An
+  * action has no transaction span.)
+  */
+  patchWhere?: (tableName: string, args: {
+    patch: Record<string, unknown>;
+    where: WhereInput;
+  }, options?: {
+    limit?: number;
+  }) => Promise<{
+    patched: number;
+  }>;
   query: (tableName: string) => TableReaderLike;
   /**
   * Return the 1-based position of `options.row` within its partition under
@@ -3806,43 +3839,6 @@ declare const MIN_AUTH_SECRET_LENGTH = 32;
 * a *missing* token is never itself a finding here (introspection is simply off).
 */
 declare const buildSecurityAudit: (rawEnv: unknown) => SecurityAuditResult;
-/**
-* Durable Object that owns auth session state.
-*
-* `@lunora/auth` used to write sessions directly into D1 alongside user
-* records. That worked but coupled session lifecycle to a global database —
-* every read had to cross the region, every write contended with user
-* inserts. SessionDO owns sessions in a DO-local KV store: same-prefix
-* tokens co-locate (via `idFromName(token.slice(0, 16))`) so the DO instance
-* count stays bounded; reads and writes never round-trip to D1.
-*
-* Wire shape: HTTP only, never RPC. The auth package calls
-*
-* `await env.SESSION.get(env.SESSION.idFromName(prefix)).fetch(...)`
-*
-* with one of:
-*
-* POST   /create   body: { token, userId, ttlSeconds }
-* GET    /get      header: `x-lunora-session-token: &lt;token>`
-* DELETE /revoke   header: `x-lunora-session-token: &lt;token>`
-*
-* Every request must additionally carry an `x-lunora-session-secret` header
-* whose value matches `env.SESSION_DO_SECRET`. The DO is reachable from any
-* worker bound to its namespace, so a shared secret is the only thing that
-* prevents a compromised or misbehaving worker from reading arbitrary
-* sessions — the binding alone is not an auth surface.
-*
-* The DO returns JSON bodies that `@lunora/auth` reshapes into its public
-* `AuthSession` type. Keep the surface narrow — anything more elaborate
-* should ride on top via a wrapper, not by widening this contract.
-*
-* # Subclassing
-*
-* Apps subclass `SessionDO` (or use the codegen subclass) and register the
-* subclass in `wrangler.jsonc` as `SESSION`. The platform DO binding requires
-* a concrete `DurableObject` class today; the structural state shape used by
-* the unit tests is preserved so plain-object doubles still work.
-*/
 /** Default TTL for new sessions (7 days), matching `@lunora/auth`. */
 declare const SESSION_DO_TTL_DEFAULT: number;
 /** Hard ceiling on the requested TTL — 90 days. Longer sessions should ride on top via refresh. */
@@ -6453,42 +6449,6 @@ declare abstract class ShardDO {
   private deliverWhisperLocal;
   private readAttachment;
 }
-/**
-* Durable Object that owns the live set of shard keys per sharded table.
-*
-* The query coordinator (`@lunora/runtime`) fans out cross-shard reads to
-* every live shard. With the static registry, the app supplies the shard
-* key list at boot — which is fine for fixed-cardinality deployments
-* (a known set of tenants) and unworkable for dynamic ones (one shard per
-* user-created channel, organisation, project, …).
-*
-* `ShardRegistryDO` is the persistent source of truth. A worker:
-*
-* - calls `POST /register {table, shardKey}` when a sharded table first
-* sees a write on a new key (typically from `ctx.db.&lt;table>.insert` via
-* the worker's onWrite hook, fired through `ctx.waitUntil` so the
-* user-facing write doesn't pay the registry round-trip);
-* - calls `POST /unregister {table, shardKey}` when a shard is decommissioned;
-* - calls `GET /list?table=X` to materialise the fan-out target list. The
-* client (`createDynamicShardRegistry` in `@lunora/runtime`) caches the
-* answer with a small TTL so a wide fan-out doesn't pay a registry
-* round-trip on every call.
-*
-* Single-instance contract: deploy one DO instance per environment, by
-* convention named {@link SHARD_REGISTRY_DO_NAME}. The DO is small (just a
-* `Map&lt;table, Set&lt;shardKey>>`) and writes are infrequent (only on first-seen
-* shardKey per table), so a single instance is sufficient up to tens of
-* thousands of distinct shard keys.
-*
-* Wire shape: HTTP only, never RPC.
-*
-* POST /register   body: { table, shardKey }
-* POST /unregister body: { table, shardKey }
-* GET  /list?table=...
-* GET  /snapshot                (debug: returns the full table → [keys] map)
-*
-* Responses are JSON; the client shapes them. Keep the surface narrow.
-*/
 /** Conventional DO instance name, passed to `idFromName` to address the single registry instance. */
 declare const SHARD_REGISTRY_DO_NAME: string;
 /**

package/dist/index.mjs

@@ -1,9 +1,9 @@
-export { exportShardRows, exportShardTable, importShardRows, parseExportShardArgs, parseImportShardArgs, selectExportTables, validateImportRow } from './packem_shared/exportShardRows-DZEhUeyI.mjs';
+export { exportShardRows, exportShardTable, importShardRows, parseExportShardArgs, parseImportShardArgs, selectExportTables, validateImportRow } from './packem_shared/exportShardRows-Dy3oFZ26.mjs';
 export { AGGREGATE_SQL_FUNCTION, aggregateSqlFunction, matchesStaticWhere, normalizeCountArgument, throwingScheduler } from './packem_shared/AGGREGATE_SQL_FUNCTION-CQsu2Xga.mjs';
 export { aggregateTableName, coerceAggregateNumber, encodeAggregateKey, foldAggregateTally, readAggregateValue } from './packem_shared/aggregateTableName-CxNqY1Sl.mjs';
 export { CountRlsUnsupportedError, mergeWhere, planAggregateLookup, selectIndexForAggregate, selectIndexForCount, selectIndexForGroupBy } from './packem_shared/CountRlsUnsupportedError-BGxj0pgS.mjs';
 export { AUTH_METRICS_BUCKETS_TABLE, AUTH_METRICS_BUCKET_MS, AUTH_METRICS_BUCKET_RETENTION, AUTH_METRICS_TABLE, ensureAuthMetricsTables, readAuthMetrics, recordAuthEvent } from './packem_shared/AUTH_METRICS_BUCKETS_TABLE-CiHHYeJi.mjs';
-export { NotUniqueError, assertValidClientId, createShardCtxDb, normalizeIdStructurally } from './packem_shared/NotUniqueError-D1U5SBFR.mjs';
+export { NotUniqueError, assertValidClientId, createShardCtxDb, normalizeIdStructurally } from './packem_shared/NotUniqueError-Dmf-HNdQ.mjs';
 export { DATA_MIGRATION_STATE_TABLE, readMigrationStatus, runDataMigration } from './packem_shared/DATA_MIGRATION_STATE_TABLE-DB3IYUR3.mjs';
 export { SCAN_DEP, createDependencyTracker, depKey } from './packem_shared/SCAN_DEP-DLJF8dsj.mjs';
 export { renderSql } from './packem_shared/renderSql-D6eUcn2N.mjs';
@@ -11,24 +11,24 @@ export { diffExternalSource } from './packem_shared/diffExternalSource-Cx9HUPJj.
 export { materializeExternalRows, readExternalSourceBaseline, runExternalSourceTick } from './packem_shared/materializeExternalRows-DNcvoLRT.mjs';
 export { isSourceDue, liftSourceId, pullExternalSourceTick } from './packem_shared/isSourceDue-BptUN8CR.mjs';
 export { FUNCTION_METRICS_BUCKETS_TABLE, FUNCTION_METRICS_BUCKET_MS, FUNCTION_METRICS_BUCKET_RETENTION, FUNCTION_METRICS_INDEX_TABLE, FUNCTION_METRICS_TABLE, ensureFunctionMetricsTables, readFunctionMetricBuckets, readFunctionMetricIndexHits, readFunctionMetrics, readFunctionMetricsTotals, recordFunctionMetric } from './packem_shared/FUNCTION_METRICS_BUCKETS_TABLE-UDNVD7FS.mjs';
-export { ADMIN_FUNCTIONS, ADMIN_FUNCTION_PREFIX, FLAGS_FUNCTION_PREFIX, RELATION_FUNCTION_PREFIX, facetColumn, listTables, readTablePage, selectMatchingIds } from './packem_shared/ADMIN_FUNCTIONS-BbQdj8h1.mjs';
+export { ADMIN_FUNCTIONS, ADMIN_FUNCTION_PREFIX, FLAGS_FUNCTION_PREFIX, RELATION_FUNCTION_PREFIX, facetColumn, listTables, readTablePage, selectMatchingIds } from './packem_shared/ADMIN_FUNCTIONS-Bxdijn66.mjs';
 export { LogBuffer } from './packem_shared/LogBuffer-B_Ezju_N.mjs';
 export { MAIL_RETENTION, MAIL_TABLE, clearCapturedMail, ensureMailTable, readCapturedMail, recordCapturedMail } from './packem_shared/MAIL_RETENTION-CPpgl-dX.mjs';
 export { default as NotFoundError } from './packem_shared/NotFoundError-C70b9hLw.mjs';
-export { armRestore, readBookmark } from './packem_shared/armRestore-BJk53Ro8.mjs';
+export { armRestore, readBookmark } from './packem_shared/armRestore-4Px61hHS.mjs';
 export { applySelect, buildSeekWhere, decodeCursor, encodeCursor, normalizeOrderKeys, softDeleteScope } from './packem_shared/applySelect-BvZdFUBT.mjs';
 export { RANK_TIEBREAK, encodePartitionKey, matchesRankStaticWhere, rankTableName, resolveRankPartition, sortColumnName } from './packem_shared/RANK_TIEBREAK-CXhdcA1o.mjs';
 export { ReactiveCache, reactiveCacheKey } from './packem_shared/ReactiveCache-BYlSGY0N.mjs';
-export { serveRelationFanout } from './packem_shared/serveRelationFanout-BhZF9AuB.mjs';
+export { serveRelationFanout } from './packem_shared/serveRelationFanout-C56hKu1O.mjs';
 export { DEFAULT_MAX_RELATION_KEYS, assertFlatPredicate, assertShapeShardable, containsRelationPredicate, isRelationPredicate, resolveRelationPredicates } from './packem_shared/DEFAULT_MAX_RELATION_KEYS-CjM9Y1_G.mjs';
 export { applyOnDelete, fanOutScalarCounts, resolveWith, runRowValidators } from './packem_shared/applyOnDelete-CAwZfp-5.mjs';
-export { RLS_UNWRAP_SYMBOL, RlsRequiredError, guardWriter } from './packem_shared/RLS_UNWRAP_SYMBOL-DnjkqVgY.mjs';
+export { RLS_UNWRAP_SYMBOL, RlsRequiredError, guardWriter } from './packem_shared/RLS_UNWRAP_SYMBOL-G1eNK4DQ.mjs';
 export { buildFtsMatch, ftsTableName, scoreDocument, stringifySearchText, tokenizeSearch } from './packem_shared/buildFtsMatch-BLEMawrp.mjs';
 export { M as MIN_ADMIN_TOKEN_LENGTH, a as MIN_AUTH_SECRET_LENGTH, b as buildSecurityAudit } from './packem_shared/security-audit-CucgBice.mjs';
-export { SESSION_DO_TTL_DEFAULT, SessionDO } from './packem_shared/SESSION_DO_TTL_DEFAULT-ilPZsVwu.mjs';
-export { ROOT_DO_SIZE_WARN_BYTES, ROOT_SHARD_NAME, ShardDO } from './packem_shared/ROOT_DO_SIZE_WARN_BYTES-BM4TOOvf.mjs';
-export { SHARD_REGISTRY_DO_NAME, ShardRegistryDO } from './packem_shared/SHARD_REGISTRY_DO_NAME-BsAbi5Mn.mjs';
-export { MAX_SQL_ROWS, assertReadonly, runReadonlySql } from './packem_shared/MAX_SQL_ROWS-dDcFE1YZ.mjs';
+export { SESSION_DO_TTL_DEFAULT, SessionDO } from './packem_shared/SESSION_DO_TTL_DEFAULT-D71QAL5h.mjs';
+export { ROOT_DO_SIZE_WARN_BYTES, ROOT_SHARD_NAME, ShardDO } from './packem_shared/ROOT_DO_SIZE_WARN_BYTES-CpURtawE.mjs';
+export { SHARD_REGISTRY_DO_NAME, ShardRegistryDO } from './packem_shared/SHARD_REGISTRY_DO_NAME-D99roc-r.mjs';
+export { MAX_SQL_ROWS, assertReadonly, runReadonlySql } from './packem_shared/MAX_SQL_ROWS-D57CJaT9.mjs';
 export { createSystemReader } from './packem_shared/createSystemReader-D12eNH13.mjs';
 export { ConflictError } from './packem_shared/ConflictError-CLoq37xH.mjs';
 export { hasTrigger, runTriggers } from './packem_shared/hasTrigger-5N6_Fx0A.mjs';

package/dist/packem_shared/{ADMIN_FUNCTIONS-BbQdj8h1.mjs → ADMIN_FUNCTIONS-Bxdijn66.mjs}

@@ -1,3 +1,5 @@
+import { LunoraError } from '@lunora/errors';
+
 const quoteIdentifier = (name) => `"${name.replaceAll('"', '""')}"`;
 
 const ADMIN_FUNCTION_PREFIX = "__lunora_admin__:";
@@ -179,7 +181,7 @@ const buildOrderBy = (orderBy, physicalColumns) => {
 const readTablePage = (sql, options) => {
   const { table } = options;
   if (isInternalTable(table) || !tableExists(sql, table)) {
-    throw Object.assign(new Error(`unknown table: ${table}`), { code: "UNKNOWN_TABLE", name: "LunoraError", status: 404 });
+    throw new LunoraError("UNKNOWN_TABLE", `unknown table: ${table}`, { status: 404 });
   }
   const limit = clamp(Math.trunc(options.limit ?? DEFAULT_PAGE_SIZE), 1, MAX_PAGE_SIZE);
   const offset = Math.max(0, Math.trunc(options.offset ?? 0));
@@ -215,7 +217,7 @@ const readTablePage = (sql, options) => {
 const selectMatchingIds = (sql, options) => {
   const { table } = options;
   if (isInternalTable(table) || !tableExists(sql, table)) {
-    throw Object.assign(new Error(`unknown table: ${table}`), { code: "UNKNOWN_TABLE", name: "LunoraError", status: 404 });
+    throw new LunoraError("UNKNOWN_TABLE", `unknown table: ${table}`, { status: 404 });
   }
   const limit = clamp(Math.trunc(options.limit ?? MAX_PAGE_SIZE), 1, MAX_PAGE_SIZE);
   const quoted = quoteIdentifier(table);
@@ -246,16 +248,16 @@ const knownDisplayColumns = (sql, quotedTable, physicalColumns) => {
 const facetColumn = (sql, options) => {
   const { column, table } = options;
   if (isInternalTable(table) || !tableExists(sql, table)) {
-    throw Object.assign(new Error(`unknown table: ${table}`), { code: "UNKNOWN_TABLE", name: "LunoraError", status: 404 });
+    throw new LunoraError("UNKNOWN_TABLE", `unknown table: ${table}`, { status: 404 });
   }
   const quoted = quoteIdentifier(table);
   const physicalColumns = sql.exec(`PRAGMA table_info(${quoted})`).toArray().map((info) => info.name);
   if (!knownDisplayColumns(sql, quoted, physicalColumns).has(column)) {
-    throw Object.assign(new Error(`unknown column: ${column}`), { code: "UNKNOWN_COLUMN", name: "LunoraError", status: 404 });
+    throw new LunoraError("UNKNOWN_COLUMN", `unknown column: ${column}`, { status: 404 });
   }
   const resolved = resolveColumnExpression(column, physicalColumns);
   if (resolved === void 0) {
-    throw Object.assign(new Error(`unknown column: ${column}`), { code: "UNKNOWN_COLUMN", name: "LunoraError", status: 404 });
+    throw new LunoraError("UNKNOWN_COLUMN", `unknown column: ${column}`, { status: 404 });
   }
   const limit = clamp(Math.trunc(options.limit ?? DEFAULT_FACET_LIMIT), 1, MAX_FACET_LIMIT);
   const needle = options.search?.trim() ?? "";

package/dist/packem_shared/{MAX_SQL_ROWS-dDcFE1YZ.mjs → MAX_SQL_ROWS-D57CJaT9.mjs}

@@ -1,10 +1,12 @@
+import { LunoraError } from '@lunora/errors';
+
 const MAX_SQL_ROWS = 1e3;
 const READONLY_LEAD = /^(?:explain\s+(?:query\s+plan\s+)?)?(?:select|with)\b/iu;
 const FORBIDDEN_KEYWORD = /\b(?:alter|attach|create|delete|detach|drop|insert|pragma|reindex|replace|truncate|update|vacuum)\b/iu;
 const LEADING_NOISE = /^(?:\s|--[^\n]*\n?|\/\*[\s\S]*?\*\/)+/u;
 const TRAILING_SEMICOLON = /;\s*$/u;
 const stripLeading = (sql) => sql.replace(LEADING_NOISE, "");
-const sqlError = (message, code) => Object.assign(new Error(message), { code, name: "LunoraError", status: 400 });
+const sqlError = (message, code) => new LunoraError(code, message, { status: 400 });
 const assertReadonly = (query) => {
   const trimmed = stripLeading(query).trim();
   if (trimmed === "") {

package/dist/packem_shared/{NotUniqueError-D1U5SBFR.mjs → NotUniqueError-Dmf-HNdQ.mjs}

@@ -16,7 +16,7 @@ import { decodeCursor, normalizeOrderKeys, buildSeekWhere, applySelect, encodeCu
 import NotFoundError from './NotFoundError-C70b9hLw.mjs';
 import { assertFlatPredicate, resolveRelationPredicates } from './DEFAULT_MAX_RELATION_KEYS-CjM9Y1_G.mjs';
 import { runRowValidators, resolveWith, applyOnDelete, fanOutScalarCounts } from './applyOnDelete-CAwZfp-5.mjs';
-import { guardWriter } from './RLS_UNWRAP_SYMBOL-DnjkqVgY.mjs';
+import { guardWriter } from './RLS_UNWRAP_SYMBOL-G1eNK4DQ.mjs';
 import { createSystemReader } from './createSystemReader-D12eNH13.mjs';
 import { ConflictError } from './ConflictError-CLoq37xH.mjs';
 import { runTriggers } from './hasTrigger-5N6_Fx0A.mjs';
@@ -483,11 +483,11 @@ const DEFAULT_BATCH_LIMIT = 500;
 const assertBatchLimit = (count, limit, op) => {
   const cap = limit ?? DEFAULT_BATCH_LIMIT;
   if (count > cap) {
-    throw Object.assign(new Error(`${op}: batch of ${String(count)} exceeds the limit of ${String(cap)} (raise options.limit or chunk the call)`), {
-      code: "BATCH_LIMIT_EXCEEDED",
-      name: "LunoraError",
-      status: 400
-    });
+    throw new LunoraError(
+      "BATCH_LIMIT_EXCEEDED",
+      `${op}: batch of ${String(count)} exceeds the limit of ${String(cap)} (raise options.limit or chunk the call)`,
+      { status: 400 }
+    );
   }
 };
 const createRangeBuilder = (stage) => {
@@ -1325,6 +1325,25 @@ const createShardCtxDb = (options) => {
       }
       return { deleted: ids.length };
     },
+    async deleteWhere(tableName, where, batchOptions) {
+      const global = globalWriterFor(tableName, "deleteWhere");
+      let ids;
+      if (global) {
+        const rows = await global.findMany(tableName, { where });
+        ids = rows.page.map((row) => String(row["_id"]));
+      } else {
+        if (!schema.tables[tableName]) {
+          throw new LunoraError("INTERNAL", `unknown table: ${tableName}`);
+        }
+        const page = await writer.findMany(tableName, { where });
+        ids = page.page.map((row) => String(row["_id"]));
+      }
+      assertBatchLimit(ids.length, batchOptions?.limit, "deleteWhere");
+      if (writer.deleteMany === void 0) {
+        throw new LunoraError("INTERNAL", `ctx.db.${tableName}.deleteMany is unavailable: this writer has no batch delete`);
+      }
+      return writer.deleteMany(ids, batchOptions);
+    },
     async findFirst(tableName, args = {}) {
       const result = await writer.findMany(tableName, { ...args, limit: 1 });
       return result.page[0] ?? null;
@@ -1614,9 +1633,18 @@ const createShardCtxDb = (options) => {
     },
     async insertMany(tableName, documents, batchOptions) {
       assertBatchLimit(documents.length, batchOptions?.limit, "insertMany");
+      const skipDuplicates = batchOptions?.skipDuplicates === true;
       const ids = [];
       for (const document of documents) {
-        ids.push(await writer.insert(tableName, document));
+        try {
+          ids.push(await writer.insert(tableName, document));
+        } catch (error) {
+          if (skipDuplicates && error instanceof ConflictError && error.kind === "unique") {
+            ids.push(null);
+          } else {
+            throw error;
+          }
+        }
       }
       return ids;
     },
@@ -1669,6 +1697,31 @@ const createShardCtxDb = (options) => {
       for (const entry of patches) {
         await writer.patch(entry.id, entry.patch, expectedTable);
       }
+      return { patched: patches.length };
+    },
+    async patchWhere(tableName, args, batchOptions) {
+      const global = globalWriterFor(tableName, "patchWhere");
+      let patches;
+      if (global) {
+        const rows = await global.findMany(tableName, { where: args.where });
+        patches = rows.page.map((row) => {
+          return { id: String(row["_id"]), patch: args.patch };
+        });
+      } else {
+        if (!schema.tables[tableName]) {
+          throw new LunoraError("INTERNAL", `unknown table: ${tableName}`);
+        }
+        const page = await writer.findMany(tableName, { where: args.where });
+        patches = page.page.map((row) => {
+          return { id: String(row["_id"]), patch: args.patch };
+        });
+      }
+      assertBatchLimit(patches.length, batchOptions?.limit, "patchWhere");
+      if (writer.patchMany === void 0) {
+        throw new LunoraError("INTERNAL", `ctx.db.${tableName}.patchMany is unavailable: this writer has no batch patch`);
+      }
+      await writer.patchMany(patches, batchOptions);
+      return { patched: patches.length };
     },
     query(tableName) {
       const global = globalWriterFor(tableName, "query");

package/dist/packem_shared/{RLS_UNWRAP_SYMBOL-DnjkqVgY.mjs → RLS_UNWRAP_SYMBOL-G1eNK4DQ.mjs}

@@ -58,6 +58,10 @@ const guardWriter = (raw, schema, tableOfId) => {
       }
       return base.deleteMany(ids, options, expectedTable);
     },
+    deleteWhere: base.deleteWhere ? async (tableName, where, options) => {
+      guardTable(tableName);
+      return await base.deleteWhere?.(tableName, where, options);
+    } : void 0,
     findFirst: (tableName, args) => {
       guardTable(tableName);
       return base.findFirst(tableName, args);
@@ -100,6 +104,10 @@ const guardWriter = (raw, schema, tableOfId) => {
       }
       return base.patchMany(patches, options, expectedTable);
     },
+    patchWhere: base.patchWhere ? async (tableName, args, options) => {
+      guardTable(tableName);
+      return await base.patchWhere?.(tableName, args, options);
+    } : void 0,
     query: (tableName) => {
       guardTable(tableName);
       return base.query(tableName);