@atscript/db-mongo 0.1.147 → 0.1.149

package/dist/agg.cjs

@@ -1,12 +1,24 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_mongo_accumulator = require("./mongo-accumulator-BJcQs2OV.cjs");
+const require_mongo_accumulator = require("./mongo-accumulator-BKMdRf3s.cjs");
+let _atscript_db = require("@atscript/db");
 let _atscript_db_agg = require("@atscript/db/agg");
 let _uniqu_core = require("@uniqu/core");
 //#region src/agg.ts
+/**
+* MongoDB aggregation pipeline builder.
+* Dynamically imported by MongoAdapter.aggregate() on first call.
+*
+* Constructs MongoDB aggregation pipelines from translated DbQuery objects
+* containing $groupBy, $select (with AggregateExpr), $having, $sort, etc.
+*/
 /** Maps an AggregateExpr to its MongoDB `$group` accumulator (see `buildAccumulator`). */
 function toAccumulator(expr) {
 	return require_mongo_accumulator.buildAccumulator(expr.$fn, expr.$field === "*" ? "*" : `$${expr.$field}`);
 }
+/** An operand of query-time arithmetic: the field as a double (IEEE, like the SQL adapters). */
+const asDouble = (path) => ({ $toDouble: `$${path}` });
+/** Prefix of the hidden `$group` field counting a sum's non-null values. */
+const NON_NULL_PREFIX = "__as_n_";
 const DAY_MS = 864e5;
 const ISO_DATE = "%Y-%m-%d";
 /** Units `$dateToString` labels straight from the instant in the zone (literal `01` for day / month). */
@@ -142,15 +154,41 @@ function buildGroupedStages(query, { accumulators, searchStage, filterOptions })
 			controls
 		};
 	}
+	const firstLast = controls.$select?.firstLast ?? [];
+	const rowOrder = controls.$select?.rowOrder ?? [];
+	if (firstLast.length > 0 && rowOrder.length > 0) pipeline.push({ $sort: Object.fromEntries(rowOrder.map((k) => [k.column, k.desc ? -1 : 1])) });
 	const project = { _id: 0 };
 	for (const [field, idKey] of groupKeys) project[field] = `$_id.${idKey}`;
+	const nullWhenEmpty = (alias, nonNull) => {
+		const count = `${NON_NULL_PREFIX}${alias}`;
+		groupStage[count] = { $sum: { $cond: [
+			nonNull,
+			1,
+			0
+		] } };
+		return { $cond: [
+			{ $eq: [`$${count}`, 0] },
+			null,
+			`$${alias}`
+		] };
+	};
 	for (const expr of controls.$select?.aggregates ?? []) {
 		const alias = (0, _atscript_db_agg.resolveAlias)(expr);
 		groupStage[alias] = toAccumulator(expr);
-		project[alias] = expr.$fn === "countDistinct" ? require_mongo_accumulator.distinctCountExpr(`$${alias}`) : 1;
+		project[alias] = expr.$fn === "countDistinct" ? require_mongo_accumulator.distinctCountExpr(`$${alias}`) : expr.$fn === "sum" ? nullWhenEmpty(alias, require_mongo_accumulator.notNullExpr(`$${expr.$field}`)) : 1;
+	}
+	for (const e of controls.$select?.exprAggregates ?? []) {
+		const value = require_mongo_accumulator.exprToMongo(e.expr, asDouble);
+		groupStage[e.alias] = { [`$${e.fn}`]: value };
+		project[e.alias] = e.fn === "sum" ? nullWhenEmpty(e.alias, require_mongo_accumulator.notNullExpr(value)) : 1;
+	}
+	for (const fl of firstLast) {
+		groupStage[fl.alias] = { [`$${fl.fn}`]: require_mongo_accumulator.orNull(`$${fl.column}`) };
+		project[fl.alias] = 1;
 	}
 	pipeline.push({ $group: groupStage });
 	pipeline.push({ $project: project });
+	for (const e of controls.$select?.exprs ?? []) pipeline.push({ $addFields: { [e.alias]: require_mongo_accumulator.exprToMongo(e.expr, asDouble) } });
 	if (controls.$having) pipeline.push({ $match: require_mongo_accumulator.buildMongoFilter(controls.$having) });
 	return {
 		pipeline,
@@ -180,6 +218,69 @@ function buildAggregatePipeline(query, searchStage, filterOptions) {
 	return pipeline;
 }
 /**
+* The row an UNGROUPED aggregate yields over no input rows: a pipeline's
+* `$group` emits nothing there, while SQL (and the memory adapter) always
+* yield the one group — counts 0, every other aggregate, `first` / `last` and
+* the expressions over them `null`. `undefined` when the query is grouped or
+* computes nothing. The row is BEFORE `$having` / `$skip` — see
+* {@link emptyGroupStages}.
+*/
+function emptyGroupRow(query) {
+	const controls = query.controls;
+	const select = controls?.$select;
+	if (!controls || controls.$groupBy?.length) return void 0;
+	if (!select?.computedAliases.length) return void 0;
+	const row = {};
+	for (const expr of select.aggregates ?? []) row[(0, _atscript_db_agg.resolveAlias)(expr)] = expr.$fn === "count" || expr.$fn === "countDistinct" ? 0 : null;
+	for (const e of select.exprAggregates ?? []) row[e.alias] = null;
+	for (const fl of select.firstLast ?? []) row[fl.alias] = null;
+	for (const e of select.exprs ?? []) row[e.alias] = (0, _atscript_db.evaluateExpr)(e.expr, (name) => row[name]);
+	return row;
+}
+/**
+* A pipeline yielding at most one document iff ANY input row matches the
+* query's filter (and search) — the probe that tells "no rows matched" (the
+* one empty group exists) from "the real group was removed by `$having`".
+*/
+function buildMatchedProbe(query, searchStage, filterOptions) {
+	const { pipeline } = buildPrefix(query, searchStage, filterOptions);
+	pipeline.push({ $limit: 1 }, { $project: { _id: 1 } });
+	return pipeline;
+}
+/**
+* The pipeline that applies the query's `$having` (and, for the row query, `$skip`
+* and `$limit`) to the {@link emptyGroupRow} — over a single synthetic document
+* (a `$facet` emits exactly one document, even from an empty input), so the
+* server evaluates `$having` exactly as it does for a real group. `undefined`
+* when there is nothing to apply (the row stands). Its result is empty when the
+* row is filtered out.
+*/
+function emptyGroupStages(query, row, forCount) {
+	const controls = query.controls;
+	const having = controls?.$having;
+	const skip = forCount ? 0 : controls?.$skip ?? 0;
+	const limit = forCount ? 0 : controls?.$limit ?? 0;
+	if (!having && !skip && !limit) return void 0;
+	const stages = [
+		{ $match: { _id: { $in: [] } } },
+		{ $facet: { one: [] } },
+		{ $replaceRoot: { newRoot: { $literal: row } } }
+	];
+	if (having) stages.push({ $match: require_mongo_accumulator.buildMongoFilter(having) });
+	if (skip) stages.push({ $skip: skip });
+	if (limit) stages.push({ $limit: limit });
+	return stages;
+}
+/**
+* `allowDiskUse` for a pipeline that sorts before it groups (`first` / `last`
+* order every matching row by `$rowOrder` first, which may exceed the
+* in-memory sort limit); `undefined` otherwise.
+*/
+function aggregateOptions(pipeline) {
+	const group = pipeline.findIndex((stage) => "$group" in stage);
+	return pipeline.slice(0, group < 0 ? 0 : group).some((stage) => "$sort" in stage) ? { allowDiskUse: true } : void 0;
+}
+/**
 * Builds a count-only pipeline: the number of groups that survive `$having`
 * (all groups when there is none). With `$having` it runs the same grouped
 * stages as the row pipeline — the accumulators must run so an alias
@@ -201,6 +302,10 @@ function buildCountPipeline(query, searchStage, filterOptions) {
 	return pipeline;
 }
 //#endregion
+exports.aggregateOptions = aggregateOptions;
 exports.bucketExpression = bucketExpression;
 exports.buildAggregatePipeline = buildAggregatePipeline;
 exports.buildCountPipeline = buildCountPipeline;
+exports.buildMatchedProbe = buildMatchedProbe;
+exports.emptyGroupRow = emptyGroupRow;
+exports.emptyGroupStages = emptyGroupStages;

package/dist/agg.d.cts

@@ -33,6 +33,38 @@ declare function bucketExpression(b: TResolvedBucket): Document;
  * filter with relational predicates (`mongoFilterStages`).
  */
 declare function buildAggregatePipeline(query: DbQuery, searchStage?: Document, filterOptions?: TMongoFilterOptions): Document[];
+/**
+ * The row an UNGROUPED aggregate yields over no input rows: a pipeline's
+ * `$group` emits nothing there, while SQL (and the memory adapter) always
+ * yield the one group — counts 0, every other aggregate, `first` / `last` and
+ * the expressions over them `null`. `undefined` when the query is grouped or
+ * computes nothing. The row is BEFORE `$having` / `$skip` — see
+ * {@link emptyGroupStages}.
+ */
+declare function emptyGroupRow(query: DbQuery): Document | undefined;
+/**
+ * A pipeline yielding at most one document iff ANY input row matches the
+ * query's filter (and search) — the probe that tells "no rows matched" (the
+ * one empty group exists) from "the real group was removed by `$having`".
+ */
+declare function buildMatchedProbe(query: DbQuery, searchStage?: Document, filterOptions?: TMongoFilterOptions): Document[];
+/**
+ * The pipeline that applies the query's `$having` (and, for the row query, `$skip`
+ * and `$limit`) to the {@link emptyGroupRow} — over a single synthetic document
+ * (a `$facet` emits exactly one document, even from an empty input), so the
+ * server evaluates `$having` exactly as it does for a real group. `undefined`
+ * when there is nothing to apply (the row stands). Its result is empty when the
+ * row is filtered out.
+ */
+declare function emptyGroupStages(query: DbQuery, row: Document, forCount: boolean): Document[] | undefined;
+/**
+ * `allowDiskUse` for a pipeline that sorts before it groups (`first` / `last`
+ * order every matching row by `$rowOrder` first, which may exceed the
+ * in-memory sort limit); `undefined` otherwise.
+ */
+declare function aggregateOptions(pipeline: Document[]): {
+  allowDiskUse: true;
+} | undefined;
 /**
  * Builds a count-only pipeline: the number of groups that survive `$having`
  * (all groups when there is none). With `$having` it runs the same grouped
@@ -47,4 +79,4 @@ declare function buildAggregatePipeline(query: DbQuery, searchStage?: Document,
  */
 declare function buildCountPipeline(query: DbQuery, searchStage?: Document, filterOptions?: TMongoFilterOptions): Document[];
 //#endregion
-export { bucketExpression, buildAggregatePipeline, buildCountPipeline };
+export { aggregateOptions, bucketExpression, buildAggregatePipeline, buildCountPipeline, buildMatchedProbe, emptyGroupRow, emptyGroupStages };

package/dist/agg.d.mts

@@ -33,6 +33,38 @@ declare function bucketExpression(b: TResolvedBucket): Document;
  * filter with relational predicates (`mongoFilterStages`).
  */
 declare function buildAggregatePipeline(query: DbQuery, searchStage?: Document, filterOptions?: TMongoFilterOptions): Document[];
+/**
+ * The row an UNGROUPED aggregate yields over no input rows: a pipeline's
+ * `$group` emits nothing there, while SQL (and the memory adapter) always
+ * yield the one group — counts 0, every other aggregate, `first` / `last` and
+ * the expressions over them `null`. `undefined` when the query is grouped or
+ * computes nothing. The row is BEFORE `$having` / `$skip` — see
+ * {@link emptyGroupStages}.
+ */
+declare function emptyGroupRow(query: DbQuery): Document | undefined;
+/**
+ * A pipeline yielding at most one document iff ANY input row matches the
+ * query's filter (and search) — the probe that tells "no rows matched" (the
+ * one empty group exists) from "the real group was removed by `$having`".
+ */
+declare function buildMatchedProbe(query: DbQuery, searchStage?: Document, filterOptions?: TMongoFilterOptions): Document[];
+/**
+ * The pipeline that applies the query's `$having` (and, for the row query, `$skip`
+ * and `$limit`) to the {@link emptyGroupRow} — over a single synthetic document
+ * (a `$facet` emits exactly one document, even from an empty input), so the
+ * server evaluates `$having` exactly as it does for a real group. `undefined`
+ * when there is nothing to apply (the row stands). Its result is empty when the
+ * row is filtered out.
+ */
+declare function emptyGroupStages(query: DbQuery, row: Document, forCount: boolean): Document[] | undefined;
+/**
+ * `allowDiskUse` for a pipeline that sorts before it groups (`first` / `last`
+ * order every matching row by `$rowOrder` first, which may exceed the
+ * in-memory sort limit); `undefined` otherwise.
+ */
+declare function aggregateOptions(pipeline: Document[]): {
+  allowDiskUse: true;
+} | undefined;
 /**
  * Builds a count-only pipeline: the number of groups that survive `$having`
  * (all groups when there is none). With `$having` it runs the same grouped
@@ -47,4 +79,4 @@ declare function buildAggregatePipeline(query: DbQuery, searchStage?: Document,
  */
 declare function buildCountPipeline(query: DbQuery, searchStage?: Document, filterOptions?: TMongoFilterOptions): Document[];
 //#endregion
-export { bucketExpression, buildAggregatePipeline, buildCountPipeline };
+export { aggregateOptions, bucketExpression, buildAggregatePipeline, buildCountPipeline, buildMatchedProbe, emptyGroupRow, emptyGroupStages };

package/dist/agg.mjs

@@ -1,11 +1,23 @@
-import { i as buildMongoFilter, n as distinctCountExpr, s as mongoFilterStages, t as buildAccumulator, u as orNull } from "./mongo-accumulator-Y_xVYo3C.mjs";
+import { d as orNull, i as buildMongoFilter, l as exprToMongo, n as distinctCountExpr, s as mongoFilterStages, t as buildAccumulator, u as notNullExpr } from "./mongo-accumulator-BvJNCVoc.mjs";
+import { evaluateExpr } from "@atscript/db";
 import { resolveAlias } from "@atscript/db/agg";
 import { BUCKET_MAX_INSTANT, BUCKET_MIN_INSTANT } from "@uniqu/core";
 //#region src/agg.ts
+/**
+* MongoDB aggregation pipeline builder.
+* Dynamically imported by MongoAdapter.aggregate() on first call.
+*
+* Constructs MongoDB aggregation pipelines from translated DbQuery objects
+* containing $groupBy, $select (with AggregateExpr), $having, $sort, etc.
+*/
 /** Maps an AggregateExpr to its MongoDB `$group` accumulator (see `buildAccumulator`). */
 function toAccumulator(expr) {
 	return buildAccumulator(expr.$fn, expr.$field === "*" ? "*" : `$${expr.$field}`);
 }
+/** An operand of query-time arithmetic: the field as a double (IEEE, like the SQL adapters). */
+const asDouble = (path) => ({ $toDouble: `$${path}` });
+/** Prefix of the hidden `$group` field counting a sum's non-null values. */
+const NON_NULL_PREFIX = "__as_n_";
 const DAY_MS = 864e5;
 const ISO_DATE = "%Y-%m-%d";
 /** Units `$dateToString` labels straight from the instant in the zone (literal `01` for day / month). */
@@ -141,15 +153,41 @@ function buildGroupedStages(query, { accumulators, searchStage, filterOptions })
 			controls
 		};
 	}
+	const firstLast = controls.$select?.firstLast ?? [];
+	const rowOrder = controls.$select?.rowOrder ?? [];
+	if (firstLast.length > 0 && rowOrder.length > 0) pipeline.push({ $sort: Object.fromEntries(rowOrder.map((k) => [k.column, k.desc ? -1 : 1])) });
 	const project = { _id: 0 };
 	for (const [field, idKey] of groupKeys) project[field] = `$_id.${idKey}`;
+	const nullWhenEmpty = (alias, nonNull) => {
+		const count = `${NON_NULL_PREFIX}${alias}`;
+		groupStage[count] = { $sum: { $cond: [
+			nonNull,
+			1,
+			0
+		] } };
+		return { $cond: [
+			{ $eq: [`$${count}`, 0] },
+			null,
+			`$${alias}`
+		] };
+	};
 	for (const expr of controls.$select?.aggregates ?? []) {
 		const alias = resolveAlias(expr);
 		groupStage[alias] = toAccumulator(expr);
-		project[alias] = expr.$fn === "countDistinct" ? distinctCountExpr(`$${alias}`) : 1;
+		project[alias] = expr.$fn === "countDistinct" ? distinctCountExpr(`$${alias}`) : expr.$fn === "sum" ? nullWhenEmpty(alias, notNullExpr(`$${expr.$field}`)) : 1;
+	}
+	for (const e of controls.$select?.exprAggregates ?? []) {
+		const value = exprToMongo(e.expr, asDouble);
+		groupStage[e.alias] = { [`$${e.fn}`]: value };
+		project[e.alias] = e.fn === "sum" ? nullWhenEmpty(e.alias, notNullExpr(value)) : 1;
+	}
+	for (const fl of firstLast) {
+		groupStage[fl.alias] = { [`$${fl.fn}`]: orNull(`$${fl.column}`) };
+		project[fl.alias] = 1;
 	}
 	pipeline.push({ $group: groupStage });
 	pipeline.push({ $project: project });
+	for (const e of controls.$select?.exprs ?? []) pipeline.push({ $addFields: { [e.alias]: exprToMongo(e.expr, asDouble) } });
 	if (controls.$having) pipeline.push({ $match: buildMongoFilter(controls.$having) });
 	return {
 		pipeline,
@@ -179,6 +217,69 @@ function buildAggregatePipeline(query, searchStage, filterOptions) {
 	return pipeline;
 }
 /**
+* The row an UNGROUPED aggregate yields over no input rows: a pipeline's
+* `$group` emits nothing there, while SQL (and the memory adapter) always
+* yield the one group — counts 0, every other aggregate, `first` / `last` and
+* the expressions over them `null`. `undefined` when the query is grouped or
+* computes nothing. The row is BEFORE `$having` / `$skip` — see
+* {@link emptyGroupStages}.
+*/
+function emptyGroupRow(query) {
+	const controls = query.controls;
+	const select = controls?.$select;
+	if (!controls || controls.$groupBy?.length) return void 0;
+	if (!select?.computedAliases.length) return void 0;
+	const row = {};
+	for (const expr of select.aggregates ?? []) row[resolveAlias(expr)] = expr.$fn === "count" || expr.$fn === "countDistinct" ? 0 : null;
+	for (const e of select.exprAggregates ?? []) row[e.alias] = null;
+	for (const fl of select.firstLast ?? []) row[fl.alias] = null;
+	for (const e of select.exprs ?? []) row[e.alias] = evaluateExpr(e.expr, (name) => row[name]);
+	return row;
+}
+/**
+* A pipeline yielding at most one document iff ANY input row matches the
+* query's filter (and search) — the probe that tells "no rows matched" (the
+* one empty group exists) from "the real group was removed by `$having`".
+*/
+function buildMatchedProbe(query, searchStage, filterOptions) {
+	const { pipeline } = buildPrefix(query, searchStage, filterOptions);
+	pipeline.push({ $limit: 1 }, { $project: { _id: 1 } });
+	return pipeline;
+}
+/**
+* The pipeline that applies the query's `$having` (and, for the row query, `$skip`
+* and `$limit`) to the {@link emptyGroupRow} — over a single synthetic document
+* (a `$facet` emits exactly one document, even from an empty input), so the
+* server evaluates `$having` exactly as it does for a real group. `undefined`
+* when there is nothing to apply (the row stands). Its result is empty when the
+* row is filtered out.
+*/
+function emptyGroupStages(query, row, forCount) {
+	const controls = query.controls;
+	const having = controls?.$having;
+	const skip = forCount ? 0 : controls?.$skip ?? 0;
+	const limit = forCount ? 0 : controls?.$limit ?? 0;
+	if (!having && !skip && !limit) return void 0;
+	const stages = [
+		{ $match: { _id: { $in: [] } } },
+		{ $facet: { one: [] } },
+		{ $replaceRoot: { newRoot: { $literal: row } } }
+	];
+	if (having) stages.push({ $match: buildMongoFilter(having) });
+	if (skip) stages.push({ $skip: skip });
+	if (limit) stages.push({ $limit: limit });
+	return stages;
+}
+/**
+* `allowDiskUse` for a pipeline that sorts before it groups (`first` / `last`
+* order every matching row by `$rowOrder` first, which may exceed the
+* in-memory sort limit); `undefined` otherwise.
+*/
+function aggregateOptions(pipeline) {
+	const group = pipeline.findIndex((stage) => "$group" in stage);
+	return pipeline.slice(0, group < 0 ? 0 : group).some((stage) => "$sort" in stage) ? { allowDiskUse: true } : void 0;
+}
+/**
 * Builds a count-only pipeline: the number of groups that survive `$having`
 * (all groups when there is none). With `$having` it runs the same grouped
 * stages as the row pipeline — the accumulators must run so an alias
@@ -200,4 +301,4 @@ function buildCountPipeline(query, searchStage, filterOptions) {
 	return pipeline;
 }
 //#endregion
-export { bucketExpression, buildAggregatePipeline, buildCountPipeline };
+export { aggregateOptions, bucketExpression, buildAggregatePipeline, buildCountPipeline, buildMatchedProbe, emptyGroupRow, emptyGroupStages };

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_mongo_accumulator = require("./mongo-accumulator-BJcQs2OV.cjs");
+const require_mongo_accumulator = require("./mongo-accumulator-BKMdRf3s.cjs");
 let _atscript_db = require("@atscript/db");
 let mongodb = require("mongodb");
 let _atscript_db_agg = require("@atscript/db/agg");
@@ -1803,6 +1803,11 @@ function objectIdFromStorage(value) {
 * predicates (see {@link MongoAdapter.supportsRelationFilters}).
 */
 const REL_WRITE_BATCH = 1e3;
+/** Whether a bulk-write error carries a write-concern failure besides (or instead of) write errors. */
+function hasWriteConcernError(error) {
+	const e = error;
+	return Boolean(e.writeConcernError || e.result?.getWriteConcernError?.() || e.result?.writeConcernErrors?.length);
+}
 var MongoAdapter = class MongoAdapter extends _atscript_db.BaseDbAdapter {
 	db;
 	client;
@@ -1915,17 +1920,28 @@ var MongoAdapter = class MongoAdapter extends _atscript_db.BaseDbAdapter {
 		});
 	}
 	async aggregate(query) {
-		const { buildAggregatePipeline, buildCountPipeline } = await Promise.resolve().then(() => require("./agg.cjs"));
+		const { aggregateOptions, buildAggregatePipeline, buildCountPipeline, buildMatchedProbe, emptyGroupRow, emptyGroupStages } = await Promise.resolve().then(() => require("./agg.cjs"));
+		const emptyGroup = async (forCount) => {
+			const row = emptyGroupRow(query);
+			if (!row) return void 0;
+			const probe = buildMatchedProbe(query, searchStage, this._predicateFilterOpts);
+			if ((await wrapInvalidQuery(() => this.aggregatePipeline(probe).toArray())).length > 0) return;
+			const stages = emptyGroupStages(query, row, forCount);
+			if (!stages) return row;
+			return (await wrapInvalidQuery(() => this.aggregatePipeline(stages).toArray()))[0];
+		};
 		const searchStage = buildAggregateSearchStage(this, query.controls);
 		if (query.controls?.$count) {
 			const pipeline = buildCountPipeline(query, searchStage, this._predicateFilterOpts);
 			this._log("aggregate (count)", pipeline);
-			const result = await wrapInvalidQuery(() => this.aggregatePipeline(pipeline).toArray());
-			return result.length > 0 ? result : [{ count: 0 }];
+			const result = await wrapInvalidQuery(() => this.aggregatePipeline(pipeline, aggregateOptions(pipeline)).toArray());
+			return result.length > 0 ? result : [{ count: await emptyGroup(true) ? 1 : 0 }];
 		}
 		const pipeline = buildAggregatePipeline(query, searchStage, this._predicateFilterOpts);
 		this._log("aggregate", pipeline);
-		return wrapInvalidQuery(() => this.aggregatePipeline(pipeline).toArray());
+		const rows = await wrapInvalidQuery(() => this.aggregatePipeline(pipeline, aggregateOptions(pipeline)).toArray());
+		const empty = rows.length === 0 ? await emptyGroup(false) : void 0;
+		return empty ? [empty] : rows;
 	}
 	get idType() {
 		const idProp = this._table.type.type.props.get("_id");
@@ -1965,10 +1981,14 @@ var MongoAdapter = class MongoAdapter extends _atscript_db.BaseDbAdapter {
 	calendarBucketUnits() {
 		return _atscript_db.ALL_BUCKET_UNITS;
 	}
-	/** Every aggregate function, `countDistinct` included. */
+	/** Every aggregate function: `countDistinct`, `first` and `last` included. */
 	aggregateFns() {
 		return _atscript_db.ALL_AGGREGATE_FNS;
 	}
+	/** Arithmetic in an aggregate `$select` (`{ $expr }`, `{ $fn, $expr }`). */
+	supportsAggregateExpressions() {
+		return true;
+	}
 	/** Computed view columns and first-row joins. */
 	viewCapabilities() {
 		return _atscript_db.ALL_VIEW_CAPABILITIES;
@@ -2426,13 +2446,17 @@ var MongoAdapter = class MongoAdapter extends _atscript_db.BaseDbAdapter {
 		try {
 			return await fn();
 		} catch (error) {
-			if (error instanceof mongodb.MongoServerError && error.code === 11e3) throw new _atscript_db.DbError("CONFLICT", [{
-				path: error.keyPattern ? Object.keys(error.keyPattern)[0] ?? "" : "",
-				message: error.message
-			}]);
-			throw error;
+			return this._mapConstraintError(error);
 		}
 	}
+	/** Rethrows a duplicate-key (11000) server error as `CONFLICT`, anything else as is. */
+	_mapConstraintError(error) {
+		if (error instanceof mongodb.MongoServerError && error.code === 11e3) throw new _atscript_db.DbError("CONFLICT", [{
+			path: error.keyPattern ? Object.keys(error.keyPattern)[0] ?? "" : "",
+			message: error.message
+		}]);
+		throw error;
+	}
 	/** An update-shaped write under {@link _wrapDuplicateKeyError}, reduced to `TDbUpdateResult`. */
 	async _wrapUpdate(fn) {
 		const { matchedCount, modifiedCount } = await this._wrapDuplicateKeyError(fn);
@@ -2456,6 +2480,98 @@ var MongoAdapter = class MongoAdapter extends _atscript_db.BaseDbAdapter {
 		return { insertedId: objectIdFromStorage(this._resolveInsertedId(data, result.insertedId)) };
 	}
 	async insertMany(data) {
+		await this._prepareInsertBatch(data);
+		this._log("insertMany", `${data.length} docs`);
+		const result = await this._wrapDuplicateKeyError(() => this.collection.insertMany(data, this._getSessionOpts()));
+		return {
+			insertedCount: result.insertedCount,
+			insertedIds: data.map((item, i) => objectIdFromStorage(this._resolveInsertedId(item, result.insertedIds[i])))
+		};
+	}
+	supportsInsertIgnore() {
+		return true;
+	}
+	/**
+	* Conflict-ignoring batch insert (the core already removed in-batch duplicates).
+	*
+	* Outside a transaction: `insertMany(…, { ordered: false })`; duplicate-key
+	* write errors (11000) mark the skipped rows, every other write error
+	* rethrows after the batch (rows already written stay — as for a plain
+	* non-transactional `insertMany`).
+	*
+	* Inside a transaction a duplicate key would abort the transaction even with
+	* `ordered: false`, so the stored keys are looked up first (inside the
+	* session), the matches are skipped and the rest is inserted ordered. A
+	* residual 11000 (e.g. a collation-equal value) throws `CONFLICT`.
+	*/
+	async insertManyIgnore(data) {
+		if (data.length === 0) return [];
+		await this._prepareInsertBatch(data);
+		this._log("insertManyIgnore", `${data.length} docs`);
+		const idOf = (item) => objectIdFromStorage(this._resolveInsertedId(item, item._id));
+		if (this._getTransactionState()) {
+			const skipped = await this._findStoredKeyConflicts(data);
+			const survivors = data.filter((_, i) => !skipped.has(i));
+			if (survivors.length > 0) await this._wrapDuplicateKeyError(() => this.collection.insertMany(survivors, {
+				ordered: true,
+				...this._getSessionOpts()
+			}));
+			return data.map((item, i) => skipped.has(i) ? null : { insertedId: idOf(item) });
+		}
+		const skipped = /* @__PURE__ */ new Set();
+		try {
+			await this.collection.insertMany(data, {
+				ordered: false,
+				...this._getSessionOpts()
+			});
+		} catch (error) {
+			if (!(error instanceof mongodb.MongoBulkWriteError)) this._mapConstraintError(error);
+			const writeErrors = [error.writeErrors].flat().filter(Boolean);
+			if (writeErrors.length === 0 || hasWriteConcernError(error)) throw error;
+			for (const writeError of writeErrors) {
+				if (writeError.code !== 11e3) throw error;
+				skipped.add(writeError.index);
+			}
+		}
+		return data.map((item, i) => skipped.has(i) ? null : { insertedId: idOf(item) });
+	}
+	/**
+	* Indices of `data` rows whose primary (`_id`) or unique-index key tuple is
+	* already stored (rows with a null / missing key component never collide).
+	* One `$or` query per chunk covers every key set.
+	*/
+	async _findStoredKeyConflicts(data) {
+		const keySets = [["_id"], ...this._table.uniqueKeySets.filter((f) => !(f.length === 1 && f[0] === "_id"))];
+		const rowTuples = data.map((row) => keySets.map((fields) => (0, _atscript_db.uniqueKeyTuple)(row, fields)));
+		const projection = Object.fromEntries(keySets.flat().map((f) => [f, 1]));
+		const stored = keySets.map(() => /* @__PURE__ */ new Set());
+		const CHUNK = 1e3;
+		for (let offset = 0; offset < data.length; offset += CHUNK) {
+			const clauses = [];
+			keySets.forEach((fields, k) => {
+				const rows = data.slice(offset, offset + CHUNK).filter((_, i) => rowTuples[offset + i][k]);
+				if (rows.length === 0) return;
+				if (fields.length === 1) clauses.push({ [fields[0]]: { $in: rows.map((row) => (0, _atscript_db.getPath)(row, fields[0])) } });
+				else for (const row of rows) clauses.push(Object.fromEntries(fields.map((f) => [f, (0, _atscript_db.getPath)(row, f)])));
+			});
+			if (clauses.length === 0) continue;
+			const found = await this.collection.find({ $or: clauses }, {
+				projection,
+				...this._getSessionOpts()
+			}).toArray();
+			for (const doc of found) keySets.forEach((fields, k) => {
+				const tuple = (0, _atscript_db.uniqueKeyTuple)(doc, fields);
+				if (tuple !== void 0) stored[k].add(tuple);
+			});
+		}
+		const skipped = /* @__PURE__ */ new Set();
+		rowTuples.forEach((tuples, i) => {
+			if (tuples.some((t, k) => t !== void 0 && stored[k].has(t))) skipped.add(i);
+		});
+		return skipped;
+	}
+	/** Version default + `@db.default.increment` allocation shared by every batch insert. */
+	async _prepareInsertBatch(data) {
 		const versionColumn = this._table.versionColumnPhysical;
 		if (versionColumn !== void 0) {
 			for (const item of data) if (!(versionColumn in item)) item[versionColumn] = 0;
@@ -2465,12 +2581,6 @@ var MongoAdapter = class MongoAdapter extends _atscript_db.BaseDbAdapter {
 			for (const item of data) for (const f of this._fieldsNeedingIncrement(item)) allFields.add(f);
 			if (allFields.size > 0) await this._assignBatchIncrements(data, allFields);
 		}
-		this._log("insertMany", `${data.length} docs`);
-		const result = await this._wrapDuplicateKeyError(() => this.collection.insertMany(data, this._getSessionOpts()));
-		return {
-			insertedCount: result.insertedCount,
-			insertedIds: data.map((item, i) => objectIdFromStorage(this._resolveInsertedId(item, result.insertedIds[i])))
-		};
 	}
 	async findOne(query) {
 		if ((0, _atscript_db.containsRelationFilter)(query.filter)) {
@@ -2894,7 +3004,7 @@ function buildMongoUpdateDoc(data, ops, versionColumn) {
 function createAdapter(connection, _options) {
 	const client = new mongodb.MongoClient(connection);
 	const db = client.db();
-	return new _atscript_db.DbSpace(() => new MongoAdapter(db, client));
+	return new _atscript_db.DbSpace(() => new MongoAdapter(db, client), { onClose: () => client.close() });
 }
 //#endregion
 exports.CollectionPatcher = CollectionPatcher;

package/dist/index.d.cts

@@ -1,5 +1,5 @@
 import { a as buildMongoFilter, c as mongoFilterStages, i as TMongoFilterPlan, l as planStages, n as TMongoFieldCollation, o as buildMongoQuery, r as TMongoFilterOptions, s as collationOfAdapter, t as REL_FILTER_TEMP_PREFIX } from "./mongo-filter-CGd9ryOD.cjs";
-import { BaseDbAdapter, DbQuery, DbSpace, FilterExpr, TColumnDiff, TDbCollation, TDbDeleteResult, TDbFieldMeta, TDbForeignKey, TDbInsertManyResult, TDbInsertResult, TDbObjectKind, TDbRelation, TDbUpdateResult, TExistingTableOption, TFieldOps, TMetadataOverrides, TPrimaryKeyChange, TSearchIndexInfo, TSyncColumnResult, TTableResolver, TViewCapability, TableMetadata, WithRelation, getKeyProps } from "@atscript/db";
+import { BaseDbAdapter, DbQuery, DbSpace, FilterExpr, TColumnDiff, TDbCollation, TDbDeleteResult, TDbFieldMeta, TDbForeignKey, TDbInsertIgnoreSlot, TDbInsertManyResult, TDbInsertResult, TDbObjectKind, TDbRelation, TDbUpdateResult, TExistingTableOption, TFieldOps, TMetadataOverrides, TPrimaryKeyChange, TSearchIndexInfo, TSyncColumnResult, TTableResolver, TViewCapability, TableMetadata, WithRelation, getKeyProps } from "@atscript/db";
 import { AggregateOptions, AggregationCursor, ClientSession, Collection, Db, Document, Filter, MongoClient, ObjectId, UpdateFilter, UpdateOptions } from "mongodb";
 import { TAtscriptAnnotatedType, TMetadataMap, TValidatorOptions, TValidatorPlugin, Validator } from "@atscript/typescript/utils";
 import { AggregateFn, BucketUnit } from "@uniqu/core";
@@ -316,8 +316,10 @@ declare class MongoAdapter extends BaseDbAdapter {
   supportsNativePatch(): boolean;
   /** Every unit, over MongoDB's bundled time zone database (see `agg.ts` `bucketExpression`). */
   calendarBucketUnits(): ReadonlySet<BucketUnit>;
-  /** Every aggregate function, `countDistinct` included. */
+  /** Every aggregate function: `countDistinct`, `first` and `last` included. */
   aggregateFns(): ReadonlySet<AggregateFn>;
+  /** Arithmetic in an aggregate `$select` (`{ $expr }`, `{ $fn, $expr }`). */
+  supportsAggregateExpressions(): boolean;
   /** Computed view columns and first-row joins. */
   viewCapabilities(): ReadonlySet<TViewCapability>;
   /**
@@ -481,10 +483,35 @@ declare class MongoAdapter extends BaseDbAdapter {
    * so a unique-index violation is a `CONFLICT` whichever statement hit it.
    */
   private _wrapDuplicateKeyError;
+  /** Rethrows a duplicate-key (11000) server error as `CONFLICT`, anything else as is. */
+  private _mapConstraintError;
   /** An update-shaped write under {@link _wrapDuplicateKeyError}, reduced to `TDbUpdateResult`. */
   private _wrapUpdate;
   insertOne(data: Record<string, unknown>): Promise<TDbInsertResult>;
   insertMany(data: Array<Record<string, unknown>>): Promise<TDbInsertManyResult>;
+  supportsInsertIgnore(): boolean;
+  /**
+   * Conflict-ignoring batch insert (the core already removed in-batch duplicates).
+   *
+   * Outside a transaction: `insertMany(…, { ordered: false })`; duplicate-key
+   * write errors (11000) mark the skipped rows, every other write error
+   * rethrows after the batch (rows already written stay — as for a plain
+   * non-transactional `insertMany`).
+   *
+   * Inside a transaction a duplicate key would abort the transaction even with
+   * `ordered: false`, so the stored keys are looked up first (inside the
+   * session), the matches are skipped and the rest is inserted ordered. A
+   * residual 11000 (e.g. a collation-equal value) throws `CONFLICT`.
+   */
+  insertManyIgnore(data: Array<Record<string, unknown>>): Promise<TDbInsertIgnoreSlot[]>;
+  /**
+   * Indices of `data` rows whose primary (`_id`) or unique-index key tuple is
+   * already stored (rows with a null / missing key component never collide).
+   * One `$or` query per chunk covers every key set.
+   */
+  private _findStoredKeyConflicts;
+  /** Version default + `@db.default.increment` allocation shared by every batch insert. */
+  private _prepareInsertBatch;
   findOne(query: DbQuery): Promise<Record<string, unknown> | null>;
   findMany(query: DbQuery): Promise<Array<Record<string, unknown>>>;
   count(query: DbQuery): Promise<number>;

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import { a as buildMongoFilter, c as mongoFilterStages, i as TMongoFilterPlan, l as planStages, n as TMongoFieldCollation, o as buildMongoQuery, r as TMongoFilterOptions, s as collationOfAdapter, t as REL_FILTER_TEMP_PREFIX } from "./mongo-filter-CGd9ryOD.mjs";
-import { BaseDbAdapter, DbQuery, DbSpace, FilterExpr, TColumnDiff, TDbCollation, TDbDeleteResult, TDbFieldMeta, TDbForeignKey, TDbInsertManyResult, TDbInsertResult, TDbObjectKind, TDbRelation, TDbUpdateResult, TExistingTableOption, TFieldOps, TMetadataOverrides, TPrimaryKeyChange, TSearchIndexInfo, TSyncColumnResult, TTableResolver, TViewCapability, TableMetadata, WithRelation, getKeyProps } from "@atscript/db";
+import { BaseDbAdapter, DbQuery, DbSpace, FilterExpr, TColumnDiff, TDbCollation, TDbDeleteResult, TDbFieldMeta, TDbForeignKey, TDbInsertIgnoreSlot, TDbInsertManyResult, TDbInsertResult, TDbObjectKind, TDbRelation, TDbUpdateResult, TExistingTableOption, TFieldOps, TMetadataOverrides, TPrimaryKeyChange, TSearchIndexInfo, TSyncColumnResult, TTableResolver, TViewCapability, TableMetadata, WithRelation, getKeyProps } from "@atscript/db";
 import { AggregateOptions, AggregationCursor, ClientSession, Collection, Db, Document, Filter, MongoClient, ObjectId, UpdateFilter, UpdateOptions } from "mongodb";
 import { AggregateFn, BucketUnit } from "@uniqu/core";
 import { TAtscriptAnnotatedType, TMetadataMap, TValidatorOptions, TValidatorPlugin, Validator } from "@atscript/typescript/utils";
@@ -316,8 +316,10 @@ declare class MongoAdapter extends BaseDbAdapter {
   supportsNativePatch(): boolean;
   /** Every unit, over MongoDB's bundled time zone database (see `agg.ts` `bucketExpression`). */
   calendarBucketUnits(): ReadonlySet<BucketUnit>;
-  /** Every aggregate function, `countDistinct` included. */
+  /** Every aggregate function: `countDistinct`, `first` and `last` included. */
   aggregateFns(): ReadonlySet<AggregateFn>;
+  /** Arithmetic in an aggregate `$select` (`{ $expr }`, `{ $fn, $expr }`). */
+  supportsAggregateExpressions(): boolean;
   /** Computed view columns and first-row joins. */
   viewCapabilities(): ReadonlySet<TViewCapability>;
   /**
@@ -481,10 +483,35 @@ declare class MongoAdapter extends BaseDbAdapter {
    * so a unique-index violation is a `CONFLICT` whichever statement hit it.
    */
   private _wrapDuplicateKeyError;
+  /** Rethrows a duplicate-key (11000) server error as `CONFLICT`, anything else as is. */
+  private _mapConstraintError;
   /** An update-shaped write under {@link _wrapDuplicateKeyError}, reduced to `TDbUpdateResult`. */
   private _wrapUpdate;
   insertOne(data: Record<string, unknown>): Promise<TDbInsertResult>;
   insertMany(data: Array<Record<string, unknown>>): Promise<TDbInsertManyResult>;
+  supportsInsertIgnore(): boolean;
+  /**
+   * Conflict-ignoring batch insert (the core already removed in-batch duplicates).
+   *
+   * Outside a transaction: `insertMany(…, { ordered: false })`; duplicate-key
+   * write errors (11000) mark the skipped rows, every other write error
+   * rethrows after the batch (rows already written stay — as for a plain
+   * non-transactional `insertMany`).
+   *
+   * Inside a transaction a duplicate key would abort the transaction even with
+   * `ordered: false`, so the stored keys are looked up first (inside the
+   * session), the matches are skipped and the rest is inserted ordered. A
+   * residual 11000 (e.g. a collation-equal value) throws `CONFLICT`.
+   */
+  insertManyIgnore(data: Array<Record<string, unknown>>): Promise<TDbInsertIgnoreSlot[]>;
+  /**
+   * Indices of `data` rows whose primary (`_id`) or unique-index key tuple is
+   * already stored (rows with a null / missing key component never collide).
+   * One `$or` query per chunk covers every key set.
+   */
+  private _findStoredKeyConflicts;
+  /** Version default + `@db.default.increment` allocation shared by every batch insert. */
+  private _prepareInsertBatch;
   findOne(query: DbQuery): Promise<Record<string, unknown> | null>;
   findMany(query: DbQuery): Promise<Array<Record<string, unknown>>>;
   count(query: DbQuery): Promise<number>;

package/dist/index.mjs

@@ -1,6 +1,6 @@
-import { a as buildMongoQuery, c as planStages, d as queryNodeToExpr, f as correlate, i as buildMongoFilter, l as exprToMongo, n as distinctCountExpr, o as collationOfAdapter, r as REL_FILTER_TEMP_PREFIX, s as mongoFilterStages, t as buildAccumulator, u as orNull } from "./mongo-accumulator-Y_xVYo3C.mjs";
-import { ALL_AGGREGATE_FNS, ALL_BUCKET_UNITS, ALL_VIEW_CAPABILITIES, BaseDbAdapter, DbError, DbSpace, andFilters, bucketTimeZoneUnavailable, computeInsights, containsRelationFilter, createFailureCollector, geoIndexNotFoundMessage, getDbFieldOp, getKeyProps, isAtscriptDbView, isFieldRef, relationStaticFilter, resolveDesignType, searchIndexNotFoundMessage, tableNameOf, translateQueryTree, vectorIndexNotFoundMessage } from "@atscript/db";
-import { MongoClient, MongoServerError, ObjectId } from "mongodb";
+import { a as buildMongoQuery, c as planStages, d as orNull, f as queryNodeToExpr, i as buildMongoFilter, l as exprToMongo, n as distinctCountExpr, o as collationOfAdapter, p as correlate, r as REL_FILTER_TEMP_PREFIX, s as mongoFilterStages, t as buildAccumulator } from "./mongo-accumulator-BvJNCVoc.mjs";
+import { ALL_AGGREGATE_FNS, ALL_BUCKET_UNITS, ALL_VIEW_CAPABILITIES, BaseDbAdapter, DbError, DbSpace, andFilters, bucketTimeZoneUnavailable, computeInsights, containsRelationFilter, createFailureCollector, geoIndexNotFoundMessage, getDbFieldOp, getKeyProps, getPath, isAtscriptDbView, isFieldRef, relationStaticFilter, resolveDesignType, searchIndexNotFoundMessage, tableNameOf, translateQueryTree, uniqueKeyTuple, vectorIndexNotFoundMessage } from "@atscript/db";
+import { MongoBulkWriteError, MongoClient, MongoServerError, ObjectId } from "mongodb";
 import { resolveAggregateSearch } from "@atscript/db/agg";
 //#region src/lib/path-utils.ts
 function joinPath(prefix, segment) {
@@ -1802,6 +1802,11 @@ function objectIdFromStorage(value) {
 * predicates (see {@link MongoAdapter.supportsRelationFilters}).
 */
 const REL_WRITE_BATCH = 1e3;
+/** Whether a bulk-write error carries a write-concern failure besides (or instead of) write errors. */
+function hasWriteConcernError(error) {
+	const e = error;
+	return Boolean(e.writeConcernError || e.result?.getWriteConcernError?.() || e.result?.writeConcernErrors?.length);
+}
 var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
 	db;
 	client;
@@ -1914,17 +1919,28 @@ var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
 		});
 	}
 	async aggregate(query) {
-		const { buildAggregatePipeline, buildCountPipeline } = await import("./agg.mjs");
+		const { aggregateOptions, buildAggregatePipeline, buildCountPipeline, buildMatchedProbe, emptyGroupRow, emptyGroupStages } = await import("./agg.mjs");
+		const emptyGroup = async (forCount) => {
+			const row = emptyGroupRow(query);
+			if (!row) return void 0;
+			const probe = buildMatchedProbe(query, searchStage, this._predicateFilterOpts);
+			if ((await wrapInvalidQuery(() => this.aggregatePipeline(probe).toArray())).length > 0) return;
+			const stages = emptyGroupStages(query, row, forCount);
+			if (!stages) return row;
+			return (await wrapInvalidQuery(() => this.aggregatePipeline(stages).toArray()))[0];
+		};
 		const searchStage = buildAggregateSearchStage(this, query.controls);
 		if (query.controls?.$count) {
 			const pipeline = buildCountPipeline(query, searchStage, this._predicateFilterOpts);
 			this._log("aggregate (count)", pipeline);
-			const result = await wrapInvalidQuery(() => this.aggregatePipeline(pipeline).toArray());
-			return result.length > 0 ? result : [{ count: 0 }];
+			const result = await wrapInvalidQuery(() => this.aggregatePipeline(pipeline, aggregateOptions(pipeline)).toArray());
+			return result.length > 0 ? result : [{ count: await emptyGroup(true) ? 1 : 0 }];
 		}
 		const pipeline = buildAggregatePipeline(query, searchStage, this._predicateFilterOpts);
 		this._log("aggregate", pipeline);
-		return wrapInvalidQuery(() => this.aggregatePipeline(pipeline).toArray());
+		const rows = await wrapInvalidQuery(() => this.aggregatePipeline(pipeline, aggregateOptions(pipeline)).toArray());
+		const empty = rows.length === 0 ? await emptyGroup(false) : void 0;
+		return empty ? [empty] : rows;
 	}
 	get idType() {
 		const idProp = this._table.type.type.props.get("_id");
@@ -1964,10 +1980,14 @@ var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
 	calendarBucketUnits() {
 		return ALL_BUCKET_UNITS;
 	}
-	/** Every aggregate function, `countDistinct` included. */
+	/** Every aggregate function: `countDistinct`, `first` and `last` included. */
 	aggregateFns() {
 		return ALL_AGGREGATE_FNS;
 	}
+	/** Arithmetic in an aggregate `$select` (`{ $expr }`, `{ $fn, $expr }`). */
+	supportsAggregateExpressions() {
+		return true;
+	}
 	/** Computed view columns and first-row joins. */
 	viewCapabilities() {
 		return ALL_VIEW_CAPABILITIES;
@@ -2425,13 +2445,17 @@ var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
 		try {
 			return await fn();
 		} catch (error) {
-			if (error instanceof MongoServerError && error.code === 11e3) throw new DbError("CONFLICT", [{
-				path: error.keyPattern ? Object.keys(error.keyPattern)[0] ?? "" : "",
-				message: error.message
-			}]);
-			throw error;
+			return this._mapConstraintError(error);
 		}
 	}
+	/** Rethrows a duplicate-key (11000) server error as `CONFLICT`, anything else as is. */
+	_mapConstraintError(error) {
+		if (error instanceof MongoServerError && error.code === 11e3) throw new DbError("CONFLICT", [{
+			path: error.keyPattern ? Object.keys(error.keyPattern)[0] ?? "" : "",
+			message: error.message
+		}]);
+		throw error;
+	}
 	/** An update-shaped write under {@link _wrapDuplicateKeyError}, reduced to `TDbUpdateResult`. */
 	async _wrapUpdate(fn) {
 		const { matchedCount, modifiedCount } = await this._wrapDuplicateKeyError(fn);
@@ -2455,6 +2479,98 @@ var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
 		return { insertedId: objectIdFromStorage(this._resolveInsertedId(data, result.insertedId)) };
 	}
 	async insertMany(data) {
+		await this._prepareInsertBatch(data);
+		this._log("insertMany", `${data.length} docs`);
+		const result = await this._wrapDuplicateKeyError(() => this.collection.insertMany(data, this._getSessionOpts()));
+		return {
+			insertedCount: result.insertedCount,
+			insertedIds: data.map((item, i) => objectIdFromStorage(this._resolveInsertedId(item, result.insertedIds[i])))
+		};
+	}
+	supportsInsertIgnore() {
+		return true;
+	}
+	/**
+	* Conflict-ignoring batch insert (the core already removed in-batch duplicates).
+	*
+	* Outside a transaction: `insertMany(…, { ordered: false })`; duplicate-key
+	* write errors (11000) mark the skipped rows, every other write error
+	* rethrows after the batch (rows already written stay — as for a plain
+	* non-transactional `insertMany`).
+	*
+	* Inside a transaction a duplicate key would abort the transaction even with
+	* `ordered: false`, so the stored keys are looked up first (inside the
+	* session), the matches are skipped and the rest is inserted ordered. A
+	* residual 11000 (e.g. a collation-equal value) throws `CONFLICT`.
+	*/
+	async insertManyIgnore(data) {
+		if (data.length === 0) return [];
+		await this._prepareInsertBatch(data);
+		this._log("insertManyIgnore", `${data.length} docs`);
+		const idOf = (item) => objectIdFromStorage(this._resolveInsertedId(item, item._id));
+		if (this._getTransactionState()) {
+			const skipped = await this._findStoredKeyConflicts(data);
+			const survivors = data.filter((_, i) => !skipped.has(i));
+			if (survivors.length > 0) await this._wrapDuplicateKeyError(() => this.collection.insertMany(survivors, {
+				ordered: true,
+				...this._getSessionOpts()
+			}));
+			return data.map((item, i) => skipped.has(i) ? null : { insertedId: idOf(item) });
+		}
+		const skipped = /* @__PURE__ */ new Set();
+		try {
+			await this.collection.insertMany(data, {
+				ordered: false,
+				...this._getSessionOpts()
+			});
+		} catch (error) {
+			if (!(error instanceof MongoBulkWriteError)) this._mapConstraintError(error);
+			const writeErrors = [error.writeErrors].flat().filter(Boolean);
+			if (writeErrors.length === 0 || hasWriteConcernError(error)) throw error;
+			for (const writeError of writeErrors) {
+				if (writeError.code !== 11e3) throw error;
+				skipped.add(writeError.index);
+			}
+		}
+		return data.map((item, i) => skipped.has(i) ? null : { insertedId: idOf(item) });
+	}
+	/**
+	* Indices of `data` rows whose primary (`_id`) or unique-index key tuple is
+	* already stored (rows with a null / missing key component never collide).
+	* One `$or` query per chunk covers every key set.
+	*/
+	async _findStoredKeyConflicts(data) {
+		const keySets = [["_id"], ...this._table.uniqueKeySets.filter((f) => !(f.length === 1 && f[0] === "_id"))];
+		const rowTuples = data.map((row) => keySets.map((fields) => uniqueKeyTuple(row, fields)));
+		const projection = Object.fromEntries(keySets.flat().map((f) => [f, 1]));
+		const stored = keySets.map(() => /* @__PURE__ */ new Set());
+		const CHUNK = 1e3;
+		for (let offset = 0; offset < data.length; offset += CHUNK) {
+			const clauses = [];
+			keySets.forEach((fields, k) => {
+				const rows = data.slice(offset, offset + CHUNK).filter((_, i) => rowTuples[offset + i][k]);
+				if (rows.length === 0) return;
+				if (fields.length === 1) clauses.push({ [fields[0]]: { $in: rows.map((row) => getPath(row, fields[0])) } });
+				else for (const row of rows) clauses.push(Object.fromEntries(fields.map((f) => [f, getPath(row, f)])));
+			});
+			if (clauses.length === 0) continue;
+			const found = await this.collection.find({ $or: clauses }, {
+				projection,
+				...this._getSessionOpts()
+			}).toArray();
+			for (const doc of found) keySets.forEach((fields, k) => {
+				const tuple = uniqueKeyTuple(doc, fields);
+				if (tuple !== void 0) stored[k].add(tuple);
+			});
+		}
+		const skipped = /* @__PURE__ */ new Set();
+		rowTuples.forEach((tuples, i) => {
+			if (tuples.some((t, k) => t !== void 0 && stored[k].has(t))) skipped.add(i);
+		});
+		return skipped;
+	}
+	/** Version default + `@db.default.increment` allocation shared by every batch insert. */
+	async _prepareInsertBatch(data) {
 		const versionColumn = this._table.versionColumnPhysical;
 		if (versionColumn !== void 0) {
 			for (const item of data) if (!(versionColumn in item)) item[versionColumn] = 0;
@@ -2464,12 +2580,6 @@ var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
 			for (const item of data) for (const f of this._fieldsNeedingIncrement(item)) allFields.add(f);
 			if (allFields.size > 0) await this._assignBatchIncrements(data, allFields);
 		}
-		this._log("insertMany", `${data.length} docs`);
-		const result = await this._wrapDuplicateKeyError(() => this.collection.insertMany(data, this._getSessionOpts()));
-		return {
-			insertedCount: result.insertedCount,
-			insertedIds: data.map((item, i) => objectIdFromStorage(this._resolveInsertedId(item, result.insertedIds[i])))
-		};
 	}
 	async findOne(query) {
 		if (containsRelationFilter(query.filter)) {
@@ -2893,7 +3003,7 @@ function buildMongoUpdateDoc(data, ops, versionColumn) {
 function createAdapter(connection, _options) {
 	const client = new MongoClient(connection);
 	const db = client.db();
-	return new DbSpace(() => new MongoAdapter(db, client));
+	return new DbSpace(() => new MongoAdapter(db, client), { onClose: () => client.close() });
 }
 //#endregion
 export { CollectionPatcher, INDEX_PREFIX, MongoAdapter, REL_FILTER_TEMP_PREFIX, buildMongoFilter, buildMongoQuery, collationOfAdapter, createAdapter, mongoFilterStages, mongoIndexKey, planStages, validateMongoIdPlugin };

package/dist/{mongo-accumulator-BJcQs2OV.cjs → mongo-accumulator-BKMdRf3s.cjs}

@@ -585,6 +585,12 @@ Object.defineProperty(exports, "mongoFilterStages", {
 		return mongoFilterStages;
 	}
 });
+Object.defineProperty(exports, "notNullExpr", {
+	enumerable: true,
+	get: function() {
+		return notNullExpr;
+	}
+});
 Object.defineProperty(exports, "orNull", {
 	enumerable: true,
 	get: function() {

package/dist/{mongo-accumulator-Y_xVYo3C.mjs → mongo-accumulator-BvJNCVoc.mjs}

@@ -531,4 +531,4 @@ function distinctCountExpr(set) {
 	return { $size: set };
 }
 //#endregion
-export { buildMongoQuery as a, planStages as c, queryNodeToExpr as d, correlate as f, buildMongoFilter as i, exprToMongo as l, distinctCountExpr as n, collationOfAdapter as o, REL_FILTER_TEMP_PREFIX as r, mongoFilterStages as s, buildAccumulator as t, orNull as u };
+export { buildMongoQuery as a, planStages as c, orNull as d, queryNodeToExpr as f, buildMongoFilter as i, exprToMongo as l, distinctCountExpr as n, collationOfAdapter as o, correlate as p, REL_FILTER_TEMP_PREFIX as r, mongoFilterStages as s, buildAccumulator as t, notNullExpr as u };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atscript/db-mongo",
-  "version": "0.1.147",
+  "version": "0.1.149",
   "description": "Mongodb plugin for atscript.",
   "keywords": [
     "atscript",
@@ -46,19 +46,19 @@
     "access": "public"
   },
   "devDependencies": {
-    "@atscript/core": "^0.1.99",
-    "@atscript/typescript": "^0.1.99",
-    "@uniqu/core": "^0.1.12",
+    "@atscript/core": "^0.1.100",
+    "@atscript/typescript": "^0.1.100",
+    "@uniqu/core": "^0.1.13",
     "mongodb": "^6.17.0",
     "mongodb-memory-server-core": "^10.0.0",
-    "unplugin-atscript": "^0.1.99"
+    "unplugin-atscript": "^0.1.100"
   },
   "peerDependencies": {
-    "@atscript/core": "^0.1.99",
-    "@atscript/typescript": "^0.1.99",
-    "@uniqu/core": "^0.1.12",
+    "@atscript/core": "^0.1.100",
+    "@atscript/typescript": "^0.1.100",
+    "@uniqu/core": "^0.1.13",
     "mongodb": "^6.17.0",
-    "@atscript/db": "^0.1.147"
+    "@atscript/db": "^0.1.149"
   },
   "scripts": {
     "postinstall": "asc -f dts",