@atscript/mongo 0.1.31 → 0.1.33

package/dist/index.mjs

@@ -1,301 +1,11 @@
-import { AnnotationSpec, isArray, isInterface, isPrimitive, isRef, isStructure } from "@atscript/core";
-import { defineAnnotatedType, flattenAnnotatedType, isAnnotatedType, isAnnotatedTypeOfPrimitive } from "@atscript/typescript/utils";
+import { AtscriptDbTable, BaseDbAdapter, getKeyProps, walkFilter } from "@atscript/utils-db";
 import { MongoClient, ObjectId } from "mongodb";
+import { defineAnnotatedType, isAnnotatedTypeOfPrimitive } from "@atscript/typescript/utils";
 
-//#region packages/mongo/src/plugin/annotations.ts
-const analyzers = [
-	"lucene.standard",
-	"lucene.simple",
-	"lucene.whitespace",
-	"lucene.english",
-	"lucene.french",
-	"lucene.german",
-	"lucene.italian",
-	"lucene.portuguese",
-	"lucene.spanish",
-	"lucene.chinese",
-	"lucene.hindi",
-	"lucene.bengali",
-	"lucene.russian",
-	"lucene.arabic"
-];
-const annotations = {
-	collection: new AnnotationSpec({
-		description: "Marks an interface as a **MongoDB collection**.\n\n- Use together with `@db.table \"name\"` which provides the collection name.\n- Automatically injects a **non-optional** `_id` field if not explicitly defined.\n- `_id` must be of type **`string`**, **`number`**, or **`mongo.objectId`**.\n\n**Example:**\n```atscript\n@db.table \"users\"\n@db.mongo.collection\nexport interface User {\n    _id: mongo.objectId\n    email: string.email\n}\n```\n",
-		nodeType: ["interface"],
-		validate(token, args, doc) {
-			const parent = token.parentNode;
-			const struc = parent?.getDefinition();
-			const errors = [];
-			if (isInterface(parent) && parent.props.has("_id") && isStructure(struc)) {
-				const _id = parent.props.get("_id");
-				const isOptional = !!_id.token("optional");
-				if (isOptional) errors.push({
-					message: `[db.mongo] _id can't be optional in Mongo Collection`,
-					severity: 1,
-					range: _id.token("identifier").range
-				});
-				const definition = _id.getDefinition();
-				if (!definition) return errors;
-				let wrongType = false;
-				if (isRef(definition)) {
-					const def = doc.unwindType(definition.id, definition.chain)?.def;
-					if (isPrimitive(def) && !["string", "number"].includes(def.config.type)) wrongType = true;
-				} else wrongType = true;
-				if (wrongType) errors.push({
-					message: `[db.mongo] _id must be of type string, number or mongo.objectId`,
-					severity: 1,
-					range: _id.token("identifier").range
-				});
-			}
-			return errors;
-		},
-		modify(token, args, doc) {
-			const parent = token.parentNode;
-			const struc = parent?.getDefinition();
-			if (isInterface(parent) && !parent.props.has("_id") && isStructure(struc)) struc.addVirtualProp({
-				name: "_id",
-				type: "mongo.objectId",
-				documentation: "Mongodb Primary Key ObjectId"
-			});
-		}
-	}),
-	autoIndexes: new AnnotationSpec({
-		description: "Switch on/off the automatic index creation. Works with as-mongo moost controller.\n\nDefault: true",
-		nodeType: ["interface"],
-		argument: {
-			name: "type",
-			type: "boolean",
-			description: "On/Off the automatic index creation"
-		}
-	}),
-	index: { text: new AnnotationSpec({
-		description: "Creates a **legacy MongoDB text index** for full-text search with optional **weight** specification.\n\nUse this when you need per-field weight control. For simple full-text indexing without weights, use the generic `@db.index.fulltext` instead.\n\n**Example:**\n```atscript\n@db.mongo.index.text 5\nbio: string\n```\n",
-		nodeType: ["prop"],
-		argument: {
-			optional: true,
-			name: "weight",
-			type: "number",
-			description: "Field importance in search results (higher = more relevant). Defaults to `1`."
-		}
-	}) },
-	search: {
-		dynamic: new AnnotationSpec({
-			description: "Creates a **dynamic MongoDB Search Index** that applies to the entire collection.\n\n- **Indexes all text fields automatically** (no need to specify fields).\n- Supports **language analyzers** for text tokenization.\n- Enables **fuzzy search** (typo tolerance) if needed.\n\n**Example:**\n```atscript\n@db.mongo.search.dynamic \"lucene.english\", 1\nexport interface MongoCollection {}\n```\n",
-			nodeType: ["interface"],
-			multiple: false,
-			argument: [{
-				optional: true,
-				name: "analyzer",
-				type: "string",
-				description: "The **text analyzer** for tokenization. Defaults to `\"lucene.standard\"`.\n\n**Available options:** `\"lucene.standard\"`, `\"lucene.english\"`, `\"lucene.spanish\"`, etc.",
-				values: analyzers
-			}, {
-				optional: true,
-				name: "fuzzy",
-				type: "number",
-				description: "Maximum typo tolerance (`0-2`). Defaults to `0` (no fuzzy search).\n\n- `0` → Exact match required.\n- `1` → Allows small typos (e.g., `\"mongo\"` ≈ `\"mango\"`).\n- `2` → More typo tolerance (e.g., `\"mongodb\"` ≈ `\"mangodb\"`)."
-			}]
-		}),
-		static: new AnnotationSpec({
-			description: "Defines a **MongoDB Atlas Search Index** for the collection. The props can refer to this index using `@db.mongo.search.text` annotation.\n\n- **Creates a named search index** for full-text search.\n- **Specify analyzers and fuzzy search** behavior at the index level.\n- **Fields must explicitly use `@db.mongo.search.text`** to be included in this search index.\n\n**Example:**\n```atscript\n@db.mongo.search.static \"lucene.english\", 1, \"mySearchIndex\"\nexport interface MongoCollection {}\n```\n",
-			nodeType: ["interface"],
-			multiple: true,
-			argument: [
-				{
-					optional: true,
-					name: "analyzer",
-					type: "string",
-					description: "The text analyzer for tokenization. Defaults to `\"lucene.standard\"`.\n\n**Available options:** `\"lucene.standard\"`, `\"lucene.english\"`, `\"lucene.spanish\"`, `\"lucene.german\"`, etc.",
-					values: analyzers
-				},
-				{
-					optional: true,
-					name: "fuzzy",
-					type: "number",
-					description: "Maximum typo tolerance (`0-2`). **Defaults to `0` (no fuzzy matching).**\n\n- `0` → No typos allowed (exact match required).\n- `1` → Allows small typos (e.g., \"mongo\" ≈ \"mango\").\n- `2` → More typo tolerance (e.g., \"mongodb\" ≈ \"mangodb\")."
-				},
-				{
-					optional: true,
-					name: "indexName",
-					type: "string",
-					description: "The name of the search index. Fields must reference this name using `@db.mongo.search.text`. If not set, defaults to `\"DEFAULT\"`."
-				}
-			]
-		}),
-		text: new AnnotationSpec({
-			description: "Marks a field to be **included in a MongoDB Atlas Search Index** defined by `@db.mongo.search.static`.\n\n- **The field has to reference an existing search index name**.\n- If index name is not defined, a new search index with default attributes will be created.\n\n**Example:**\n```atscript\n@db.mongo.search.text \"lucene.english\", \"mySearchIndex\"\nfirstName: string\n```\n",
-			nodeType: ["prop"],
-			multiple: true,
-			argument: [{
-				optional: true,
-				name: "analyzer",
-				type: "string",
-				description: "The text analyzer for tokenization. Defaults to `\"lucene.standard\"`.\n\n**Available options:** `\"lucene.standard\"`, `\"lucene.english\"`, `\"lucene.spanish\"`, `\"lucene.german\"`, etc.",
-				values: analyzers
-			}, {
-				optional: true,
-				name: "indexName",
-				type: "string",
-				description: "The **name of the search index** defined in `@db.mongo.search.static`. This links the field to the correct index. If not set, defaults to `\"DEFAULT\"`."
-			}]
-		}),
-		vector: new AnnotationSpec({
-			description: "Creates a **MongoDB Vector Search Index** for **semantic search, embeddings, and AI-powered search**.\n\n- Each field that stores vector embeddings **must define its own vector index**.\n- Supports **cosine similarity, Euclidean distance, and dot product similarity**.\n- Vector fields must be an **array of numbers**.\n\n**Example:**\n```atscript\n@db.mongo.search.vector 512, \"cosine\"\nembedding: mongo.vector\n```\n",
-			nodeType: ["prop"],
-			multiple: false,
-			argument: [
-				{
-					optional: false,
-					name: "dimensions",
-					type: "number",
-					description: "The **number of dimensions in the vector** (e.g., 512 for OpenAI embeddings).",
-					values: [
-						"512",
-						"768",
-						"1024",
-						"1536",
-						"3072",
-						"4096"
-					]
-				},
-				{
-					optional: true,
-					name: "similarity",
-					type: "string",
-					description: "The **similarity metric** used for vector search. Defaults to `\"cosine\"`.\n\n**Available options:** `\"cosine\"`, `\"euclidean\"`, `\"dotProduct\"`.",
-					values: [
-						"cosine",
-						"euclidean",
-						"dotProduct"
-					]
-				},
-				{
-					optional: true,
-					name: "indexName",
-					type: "string",
-					description: "The **name of the vector search index** (optional, defaults to property name)."
-				}
-			]
-		}),
-		filter: new AnnotationSpec({
-			description: "Assigns a field as a **filter field** for a **MongoDB Vector Search Index**.\n\n- The assigned field **must be indexed** for efficient filtering.\n- Filters allow vector search queries to return results **only within a specific category, user group, or tag**.\n- The vector index must be defined using `@db.mongo.search.vector`.\n\n**Example:**\n```atscript\n@db.mongo.search.vector 512, \"cosine\"\nembedding: number[]\n\n@db.mongo.search.filter \"embedding\"\ncategory: string\n```\n",
-			nodeType: ["prop"],
-			multiple: true,
-			argument: [{
-				optional: false,
-				name: "indexName",
-				type: "string",
-				description: "The **name of the vector search index** this field should be used as a filter for."
-			}]
-		})
-	},
-	patch: { strategy: new AnnotationSpec({
-		description: "Defines the **patching strategy** for updating MongoDB documents.\n\n- **\"replace\"** → The field or object will be **fully replaced**.\n- **\"merge\"** → The field or object will be **merged recursively** (applies only to objects, not arrays).\n\n**Example:**\n```atscript\n@db.mongo.patch.strategy \"merge\"\nsettings: {\n  notifications: boolean\n  preferences: {\n    theme: string\n  }\n}\n```\n",
-		nodeType: ["prop"],
-		multiple: false,
-		argument: {
-			name: "strategy",
-			type: "string",
-			description: "The **patch strategy** for this field: `\"replace\"` (default) or `\"merge\"`.",
-			values: ["replace", "merge"]
-		},
-		validate(token, args, doc) {
-			const field = token.parentNode;
-			const errors = [];
-			const definition = field.getDefinition();
-			if (!definition) return errors;
-			let wrongType = false;
-			if (isRef(definition)) {
-				const def = doc.unwindType(definition.id, definition.chain)?.def;
-				if (!isStructure(def) && !isInterface(def) && !isArray(def)) wrongType = true;
-			} else if (!isStructure(definition) && !isInterface(definition) && !isArray(definition)) wrongType = true;
-			if (wrongType) errors.push({
-				message: `[db.mongo] type of object or array expected when using @db.mongo.patch.strategy`,
-				severity: 1,
-				range: token.range
-			});
-			return errors;
-		}
-	}) },
-	array: { uniqueItems: new AnnotationSpec({
-		description: "Marks an **array field** as containing *globally unique items* when handling **patch `$insert` operations**.\n\n- Forces the patcher to use **set-semantics** (`$setUnion`) instead of a plain append, so duplicates are silently skipped.\n- Has **no effect** on `$replace`, `$update`, or `$remove`.\n- If the array's element type already defines one or more `@expect.array.key` properties, *uniqueness is implied* and this annotation is unnecessary (but harmless).\n\n**Example:**\n```atscript\n@db.mongo.array.uniqueItems\ntags: string[]\n\n// Later in a patch payload …\n{\n  $insert: {\n    tags: [\"mongo\", \"mongo\"] // second \"mongo\" is ignored\n  }\n}\n```\n",
-		nodeType: ["prop"],
-		multiple: false,
-		validate(token, args, doc) {
-			const field = token.parentNode;
-			const errors = [];
-			const definition = field.getDefinition();
-			if (!definition) return errors;
-			let wrongType = false;
-			if (isRef(definition)) {
-				const def = doc.unwindType(definition.id, definition.chain)?.def;
-				if (!isArray(def)) wrongType = true;
-			} else if (!isArray(definition)) wrongType = true;
-			if (wrongType) errors.push({
-				message: `[db.mongo] type of array expected when using @db.mongo.array.uniqueItems`,
-				severity: 1,
-				range: token.range
-			});
-			return errors;
-		}
-	}) }
-};
-
-//#endregion
-//#region packages/mongo/src/plugin/primitives.ts
-const primitives = { mongo: { extensions: {
-	objectId: {
-		type: "string",
-		documentation: "Represents a **MongoDB ObjectId**.\n\n- Stored as a **string** but can be converted to an ObjectId at runtime.\n- Useful for handling `_id` fields and queries that require ObjectId conversion.\n- Automatically converts string `_id` values into **MongoDB ObjectId** when needed.\n\n**Example:**\n```atscript\nuserId: mongo.objectId\n```\n",
-		annotations: { "expect.pattern": { pattern: "^[a-fA-F0-9]{24}$" } }
-	},
-	vector: {
-		type: {
-			kind: "array",
-			of: "number"
-		},
-		documentation: "Represents a **MongoDB Vector (Array of Numbers)** for **Vector Search**.\n\n- Equivalent to `number[]` but explicitly used for **vector embeddings**.\n\n**Example:**\n```atscript\nembedding: mongo.vector\n```\n"
-	}
-} } };
-
-//#endregion
-//#region packages/mongo/src/plugin/index.ts
-const MongoPlugin = () => ({
-	name: "mongo",
-	config() {
-		return {
-			primitives,
-			annotations: { db: { mongo: annotations } }
-		};
-	}
-});
-
-//#endregion
 //#region packages/mongo/src/lib/validate-plugins.ts
 const validateMongoIdPlugin = (ctx, def, value) => {
 	if (ctx.path === "_id" && def.type.tags.has("objectId")) return ctx.validateAnnotatedType(def, value instanceof ObjectId ? value.toString() : value);
 };
-const validateMongoUniqueArrayItemsPlugin = (ctx, def, value) => {
-	if (def.metadata.has("db.mongo.array.uniqueItems") && def.type.kind === "array") {
-		if (Array.isArray(value)) {
-			const separator = "▼↩";
-			const seen = new Set();
-			const keyProps = CollectionPatcher.getKeyProps(def);
-			for (const item of value) {
-				let key = "";
-				if (keyProps.size > 0) for (const prop of keyProps) key += JSON.stringify(item[prop]) + separator;
-else key = JSON.stringify(item);
-				if (seen.has(key)) {
-					ctx.error(`Duplicate items are not allowed`);
-					return false;
-				}
-				seen.add(key);
-			}
-		}
-	}
-	return undefined;
-};
 
 //#endregion
 //#region packages/mongo/src/lib/collection-patcher.ts
@@ -310,45 +20,29 @@ else obj[key] = value;
 	return obj;
 }
 var CollectionPatcher = class CollectionPatcher {
-	/**
-	* Extract a set of *key properties* (annotated with `@expect.array.key`) from an
-	* array‐of‐objects type definition. These keys uniquely identify an element
-	* inside the array and are later used for `$update`, `$remove` and `$upsert`.
-	*
-	* @param def Atscript array type
-	* @returns Set of property names marked as keys; empty set if none
-	*/ static getKeyProps(def) {
-		if (def.type.of.type.kind === "object") {
-			const objType = def.type.of.type;
-			const keyProps = new Set();
-			for (const [key, val] of objType.props.entries()) if (val.metadata.get("expect.array.key")) keyProps.add(key);
-			return keyProps;
-		}
-		return new Set();
-	}
 	/**
 	* Build a runtime *Validator* that understands the extended patch payload.
 	*
 	*  * Adds per‑array *patch* wrappers (the `$replace`, `$insert`, … fields).
-	*  * Honors `db.mongo.patch.strategy === "merge"` metadata.
+	*  * Honors `db.patch.strategy === "merge"` metadata.
 	*
 	* @param collection Target collection wrapper
 	* @returns Atscript Validator
-	*/ static prepareValidator(collection) {
-		return collection.createValidator({
-			plugins: [validateMongoIdPlugin, validateMongoUniqueArrayItemsPlugin],
+	*/ static prepareValidator(context) {
+		return context.createValidator({
+			plugins: [validateMongoIdPlugin],
 			replace: (def, path) => {
 				if (path === "" && def.type.kind === "object") {
 					const obj = defineAnnotatedType("object").copyMetadata(def.metadata);
 					for (const [prop, type] of def.type.props.entries()) obj.prop(prop, defineAnnotatedType().refTo(type).copyMetadata(type.metadata).optional(prop !== "_id").$type);
 					return obj.$type;
 				}
-				if (def.type.kind === "array" && collection.flatMap.get(path)?.metadata.get("db.mongo.__topLevelArray") && !def.metadata.has("db.mongo.__patchArrayValue")) {
+				if (def.type.kind === "array" && context.flatMap.get(path)?.metadata.get("db.mongo.__topLevelArray") && !def.metadata.has("db.mongo.__patchArrayValue")) {
 					const defArray = def;
-					const mergeStrategy = defArray.metadata.get("db.mongo.patch.strategy") === "merge";
+					const mergeStrategy = defArray.metadata.get("db.patch.strategy") === "merge";
 					function getPatchType() {
-						const isPrimitive$1 = isAnnotatedTypeOfPrimitive(defArray.type.of);
-						if (isPrimitive$1) return defineAnnotatedType().refTo(def).copyMetadata(def.metadata).annotate("db.mongo.__patchArrayValue").optional().$type;
+						const isPrimitive = isAnnotatedTypeOfPrimitive(defArray.type.of);
+						if (isPrimitive) return defineAnnotatedType().refTo(def).copyMetadata(def.metadata).annotate("db.mongo.__patchArrayValue").optional().$type;
 						if (defArray.type.of.type.kind === "object") {
 							const objType = defArray.type.of.type;
 							const t = defineAnnotatedType("object").copyMetadata(defArray.type.of.metadata);
@@ -366,7 +60,7 @@ else t.prop(key, defineAnnotatedType().refTo(val).copyMetadata(def.metadata).opt
 				}
 				return def;
 			},
-			partial: (def, path) => path !== "" && def.metadata.get("db.mongo.patch.strategy") === "merge"
+			partial: (def, path) => path !== "" && def.metadata.get("db.patch.strategy") === "merge"
 		});
 	}
 	/**
@@ -396,14 +90,12 @@ else t.prop(key, defineAnnotatedType().refTo(val).copyMetadata(def.metadata).opt
 	* @param val Value to be written
 	* @private
 	*/ _set(key, val) {
-		for (const pipe of this.updatePipeline) {
-			if (!pipe.$set) pipe.$set = {};
-			if (!pipe.$set[key]) {
-				pipe.$set[key] = val;
-				return;
-			}
+		if (this.currentSetStage && !(key in this.currentSetStage.$set)) {
+			this.currentSetStage.$set[key] = val;
+			return;
 		}
-		this.updatePipeline.push({ $set: { [key]: val } });
+		this.currentSetStage = { $set: { [key]: val } };
+		this.updatePipeline.push(this.currentSetStage);
 	}
 	/**
 	* Recursively walk through the patch *payload* and convert it into `$set`/…
@@ -418,8 +110,8 @@ else t.prop(key, defineAnnotatedType().refTo(val).copyMetadata(def.metadata).opt
 			const key = evalKey(_key);
 			const flatType = this.collection.flatMap.get(key);
 			const topLevelArray = flatType?.metadata?.get("db.mongo.__topLevelArray");
-			if (typeof value === "object" && topLevelArray) this.parseArrayPatch(key, value);
-else if (typeof value === "object" && this.collection.flatMap.get(key)?.metadata?.get("db.mongo.patch.strategy") === "merge") this.flattenPayload(value, key);
+			if (typeof value === "object" && topLevelArray) this.parseArrayPatch(key, value, flatType);
+else if (typeof value === "object" && flatType?.metadata?.get("db.patch.strategy") === "merge") this.flattenPayload(value, key);
 else if (key !== "_id") this._set(key, value);
 		}
 		return this.updatePipeline;
@@ -431,19 +123,19 @@ else if (key !== "_id") this._set(key, value);
 	* @param key   Dotted path to the array field
 	* @param value Payload slice for that field
 	* @private
-	*/ parseArrayPatch(key, value) {
-		const flatType = this.collection.flatMap.get(key);
+	*/ parseArrayPatch(key, value, flatType) {
 		const toRemove = value.$remove;
 		const toReplace = value.$replace;
 		const toInsert = value.$insert;
 		const toUpsert = value.$upsert;
 		const toUpdate = value.$update;
-		const keyProps = flatType?.type.kind === "array" ? CollectionPatcher.getKeyProps(flatType) : new Set();
-		this._remove(key, toRemove, keyProps);
+		const keyProps = flatType.type.kind === "array" ? getKeyProps(flatType) : new Set();
+		const keys = keyProps.size > 0 ? [...keyProps] : [];
+		this._remove(key, toRemove, keys, flatType);
 		this._replace(key, toReplace);
-		this._insert(key, toInsert, keyProps);
-		this._upsert(key, toUpsert, keyProps);
-		this._update(key, toUpdate, keyProps);
+		this._insert(key, toInsert, keys, flatType);
+		this._upsert(key, toUpsert, keys, flatType);
+		this._update(key, toUpdate, keys, flatType);
 	}
 	/**
 	* Build an *aggregation‐expression* that checks equality by **all** keys in
@@ -456,7 +148,8 @@ else if (key !== "_id") this._set(key, value);
 	* @param left  Base token for *left* expression (e.g. `"$$el"`)
 	* @param right Base token for *right* expression (e.g. `"$$this"`)
 	*/ _keysEqual(keys, left, right) {
-		return keys.map((k) => ({ $eq: [`${left}.${k}`, `${right}.${k}`] })).reduce((acc, cur) => acc ? { $and: [acc, cur] } : cur);
+		const eqs = keys.map((k) => ({ $eq: [`${left}.${k}`, `${right}.${k}`] }));
+		return eqs.length === 1 ? eqs[0] : { $and: eqs };
 	}
 	/**
 	* `$replace` – overwrite the entire array with `input`.
@@ -471,20 +164,19 @@ else if (key !== "_id") this._set(key, value);
 	* `$insert`
 	* - plain append      → $concatArrays
 	* - unique / keyed    → delegate to _upsert (insert-or-update)
-	*/ _insert(key, input, keyProps) {
+	*/ _insert(key, input, keys, flatType) {
 		if (!input?.length) return;
-		const uniqueItems = this.collection.flatMap.get(key)?.metadata?.has("db.mongo.array.uniqueItems");
-		if (uniqueItems || keyProps.size > 0) this._upsert(key, input, keyProps);
+		const uniqueItems = flatType.metadata?.has("expect.array.uniqueItems");
+		if (uniqueItems || keys.length > 0) this._upsert(key, input, keys, flatType);
 else this._set(key, { $concatArrays: [{ $ifNull: [`$${key}`, []] }, input] });
 	}
 	/**
 	* `$upsert`
 	* - keyed  → remove existing matching by key(s) then append candidate
 	* - unique → $setUnion (deep equality)
-	*/ _upsert(key, input, keyProps) {
+	*/ _upsert(key, input, keys, _flatType) {
 		if (!input?.length) return;
-		if (keyProps.size > 0) {
-			const keys = [...keyProps];
+		if (keys.length > 0) {
 			this._set(key, { $reduce: {
 				input,
 				initialValue: { $ifNull: [`$${key}`, []] },
@@ -508,11 +200,10 @@ else this._set(key, { $concatArrays: [{ $ifNull: [`$${key}`, []] }, input] });
 	* `$update`
 	* - keyed       → map array and merge / replace matching element(s)
 	* - non-keyed   → behave like `$addToSet` (insert only when not present)
-	*/ _update(key, input, keyProps) {
+	*/ _update(key, input, keys, flatType) {
 		if (!input?.length) return;
-		if (keyProps.size > 0) {
-			const mergeStrategy = this.collection.flatMap.get(key)?.metadata?.get("db.mongo.patch.strategy") === "merge";
-			const keys = [...keyProps];
+		if (keys.length > 0) {
+			const mergeStrategy = flatType.metadata?.get("db.patch.strategy") === "merge";
 			this._set(key, { $reduce: {
 				input,
 				initialValue: { $ifNull: [`$${key}`, []] },
@@ -532,23 +223,21 @@ else this._set(key, { $concatArrays: [{ $ifNull: [`$${key}`, []] }, input] });
 	* `$remove`
 	* - keyed     → filter out any element whose key set matches a payload item
 	* - non-keyed → deep equality remove (`$setDifference`)
-	*/ _remove(key, input, keyProps) {
+	*/ _remove(key, input, keys, _flatType) {
 		if (!input?.length) return;
-		if (keyProps.size > 0) {
-			const keys = [...keyProps];
-			this._set(key, { $let: {
-				vars: { rem: input },
-				in: { $filter: {
-					input: { $ifNull: [`$${key}`, []] },
-					as: "el",
-					cond: { $not: { $anyElementTrue: { $map: {
-						input: "$$rem",
-						as: "r",
-						in: this._keysEqual(keys, "$$el", "$$r")
-					} } } }
-				} }
-			} });
-		} else this._set(key, { $setDifference: [{ $ifNull: [`$${key}`, []] }, input] });
+		if (keys.length > 0) this._set(key, { $let: {
+			vars: { rem: input },
+			in: { $filter: {
+				input: { $ifNull: [`$${key}`, []] },
+				as: "el",
+				cond: { $not: { $anyElementTrue: { $map: {
+					input: "$$rem",
+					as: "r",
+					in: this._keysEqual(keys, "$$el", "$$r")
+				} } } }
+			} }
+		} });
+else this._set(key, { $setDifference: [{ $ifNull: [`$${key}`, []] }, input] });
 	}
 	constructor(collection, payload) {
 		_define_property$2(this, "collection", void 0);
@@ -558,27 +247,47 @@ else this._set(key, { $concatArrays: [{ $ifNull: [`$${key}`, []] }, input] });
 		* Filled only with the `_id` field right now.
 		*/ _define_property$2(this, "filterObj", void 0);
 		/** MongoDB *update* document being built. */ _define_property$2(this, "updatePipeline", void 0);
+		/** Current `$set` stage being populated. */ _define_property$2(this, "currentSetStage", void 0);
 		/** Additional *options* (mainly `arrayFilters`). */ _define_property$2(this, "optionsObj", void 0);
 		this.collection = collection;
 		this.payload = payload;
 		this.filterObj = {};
 		this.updatePipeline = [];
+		this.currentSetStage = null;
 		this.optionsObj = {};
 	}
 };
+_define_property$2(CollectionPatcher, "getKeyProps", getKeyProps);
 
 //#endregion
-//#region packages/mongo/src/lib/logger.ts
-const NoopLogger = {
-	error: () => {},
-	warn: () => {},
-	log: () => {},
-	info: () => {},
-	debug: () => {}
+//#region packages/mongo/src/lib/mongo-filter.ts
+const EMPTY = {};
+const mongoVisitor = {
+	comparison(field, op, value) {
+		if (op === "$eq") return { [field]: value };
+		return { [field]: { [op]: value } };
+	},
+	and(children) {
+		if (children.length === 0) return EMPTY;
+		if (children.length === 1) return children[0];
+		return { $and: children };
+	},
+	or(children) {
+		if (children.length === 0) return { _impossible: true };
+		if (children.length === 1) return children[0];
+		return { $or: children };
+	},
+	not(child) {
+		return { $nor: [child] };
+	}
 };
+function buildMongoFilter(filter) {
+	if (!filter || Object.keys(filter).length === 0) return EMPTY;
+	return walkFilter(filter, mongoVisitor);
+}
 
 //#endregion
-//#region packages/mongo/src/lib/as-collection.ts
+//#region packages/mongo/src/lib/mongo-adapter.ts
 function _define_property$1(obj, key, value) {
 	if (key in obj) Object.defineProperty(obj, key, {
 		value,
@@ -591,43 +300,38 @@ else obj[key] = value;
 }
 const INDEX_PREFIX = "atscript__";
 const DEFAULT_INDEX_NAME = "DEFAULT";
-/**
-* Generates a key for mongo index
-* @param type index type
-* @param name index name
-* @returns index key
-*/ function indexKey(type, name) {
+function mongoIndexKey(type, name) {
 	const cleanName = name.replace(/[^a-z0-9_.-]/gi, "_").replace(/_+/g, "_").slice(0, 127 - INDEX_PREFIX.length - type.length - 2);
 	return `${INDEX_PREFIX}${type}__${cleanName}`;
 }
-var AsCollection = class {
-	createValidator(opts) {
-		return this._type.validator(opts);
+var MongoAdapter = class extends BaseDbAdapter {
+	get collection() {
+		if (!this._collection) this._collection = this.db.collection(this.resolveTableName(false));
+		return this._collection;
 	}
-	async exists() {
-		return this.asMongo.collectionExists(this.name);
+	aggregate(pipeline) {
+		return this.collection.aggregate(pipeline);
 	}
-	async ensureExists() {
-		const exists = await this.exists();
-		if (!exists) await this.asMongo.db.createCollection(this.name, { comment: "Created by Atscript Mongo Collection" });
-	}
-	/**
-	* Returns the a type definition of the "_id" prop.
-	*/ get idType() {
-		const idProp = this.type.type.props.get("_id");
+	get idType() {
+		const idProp = this._table.type.type.props.get("_id");
 		const idTags = idProp?.type.tags;
 		if (idTags?.has("objectId") && idTags?.has("mongo")) return "objectId";
 		if (idProp?.type.kind === "") return idProp.type.designType;
 		return "objectId";
 	}
+	prepareId(id, fieldType) {
+		const tags = fieldType.type.tags;
+		if (tags?.has("objectId") && tags?.has("mongo")) return id instanceof ObjectId ? id : new ObjectId(id);
+		if (fieldType.type.kind === "") {
+			const dt = fieldType.type.designType;
+			if (dt === "number") return Number(id);
+		}
+		return String(id);
+	}
 	/**
-	* Transforms an "_id" value to the expected type (`ObjectId`, `number`, or `string`).
-	* Assumes input has already been validated.
-	*
-	* @param {string | number | ObjectId} id - The validated ID.
-	* @returns {string | number | ObjectId} - The transformed ID.
-	* @throws {Error} If the `_id` type is unknown.
-	*/ prepareId(id) {
+	* Convenience method that uses `idType` to transform an ID value.
+	* For use in controllers that don't have access to the field type.
+	*/ prepareIdFromIdType(id) {
 		switch (this.idType) {
 			case "objectId": return id instanceof ObjectId ? id : new ObjectId(id);
 			case "number": return Number(id);
@@ -635,91 +339,59 @@ var AsCollection = class {
 			default: throw new Error("Unknown \"_id\" type");
 		}
 	}
-	/**
-	* Retrieves a validator for a given purpose. If the validator is not already cached,
-	* it creates and stores a new one based on the purpose.
-	*
-	* @param {TValidatorPurpose} purpose - The validation purpose (`input`, `update`, `patch`).
-	* @returns {Validator} The corresponding validator instance.
-	* @throws {Error} If an unknown purpose is provided.
-	*/ getValidator(purpose) {
-		if (!this.validators.has(purpose)) switch (purpose) {
-			case "insert": {
-				this.validators.set(purpose, this.createValidator({
-					plugins: [validateMongoIdPlugin, validateMongoUniqueArrayItemsPlugin],
-					replace(type, path) {
-						if (path === "_id" && type.type.tags.has("objectId")) return {
-							...type,
-							optional: true
-						};
-						return type;
-					}
-				}));
-				break;
-			}
-			case "update": {
-				this.validators.set(purpose, this.createValidator({ plugins: [validateMongoIdPlugin] }));
-				break;
+	supportsNestedObjects() {
+		return true;
+	}
+	supportsNativePatch() {
+		return true;
+	}
+	getValidatorPlugins() {
+		return [validateMongoIdPlugin];
+	}
+	getTopLevelArrayTag() {
+		return "db.mongo.__topLevelArray";
+	}
+	getAdapterTableName(type) {
+		return undefined;
+	}
+	buildInsertValidator(table) {
+		return table.createValidator({
+			plugins: this.getValidatorPlugins(),
+			replace: (type, path) => {
+				if (path === "_id" && type.type.tags?.has("objectId")) return {
+					...type,
+					optional: true
+				};
+				if (table.defaults.has(path)) return {
+					...type,
+					optional: true
+				};
+				return type;
 			}
-			case "patch": {
-				this.validators.set(purpose, CollectionPatcher.prepareValidator(this));
-				break;
-			}
-			default: throw new Error(`Unknown validator purpose: ${purpose}`);
-		}
-		return this.validators.get(purpose);
-	}
-	get type() {
-		return this._type;
+		});
 	}
-	get indexes() {
-		this._flatten();
-		return this._indexes;
+	buildPatchValidator(table) {
+		return CollectionPatcher.prepareValidator(this.getPatcherContext());
 	}
-	_addIndexField(type, name, field, weight) {
-		const key = indexKey(type, name);
-		let index = this._indexes.get(key);
-		const value = type === "text" ? "text" : 1;
-		if (index) index.fields[field] = value;
-else {
-			const weights = {};
-			index = {
-				key,
-				name,
-				type,
-				fields: { [field]: value },
-				weights
-			};
-			this._indexes.set(key, index);
-		}
-		if (weight) index.weights[field] = weight;
-	}
-	_setSearchIndex(type, name, definition) {
-		const key = indexKey(type, name || DEFAULT_INDEX_NAME);
-		this._indexes.set(key, {
-			key,
-			name: name || DEFAULT_INDEX_NAME,
-			type,
-			definition
-		});
+	/** Returns the context object used by CollectionPatcher. */ getPatcherContext() {
+		return {
+			flatMap: this._table.flatMap,
+			prepareId: (id) => this.prepareIdFromIdType(id),
+			createValidator: (opts) => this._table.createValidator(opts)
+		};
 	}
-	_addFieldToSearchIndex(type, _name, fieldName, analyzer) {
-		const name = _name || DEFAULT_INDEX_NAME;
-		let index = this._indexes.get(indexKey(type, name));
-		if (!index && type === "search_text") {
-			this._setSearchIndex(type, name, {
-				mappings: { fields: {} },
-				text: { fuzzy: { maxEdits: 0 } }
-			});
-			index = this._indexes.get(indexKey(type, name));
-		}
-		if (index) {
-			index.definition.mappings.fields[fieldName] = { type: "string" };
-			if (analyzer) index.definition.mappings.fields[fieldName].analyzer = analyzer;
-		}
+	async nativePatch(filter, patch) {
+		const mongoFilter = buildMongoFilter(filter);
+		const patcher = new CollectionPatcher(this.getPatcherContext(), patch);
+		const { updateFilter, updateOptions } = patcher.preparePatch();
+		const result = await this.collection.updateOne(mongoFilter, updateFilter, updateOptions);
+		return {
+			matchedCount: result.matchedCount,
+			modifiedCount: result.modifiedCount
+		};
 	}
-	_prepareIndexesForCollection() {
-		const typeMeta = this.type.metadata;
+	onBeforeFlatten(type) {
+		const typeMeta = type.metadata;
 		const dynamicText = typeMeta.get("db.mongo.search.dynamic");
 		if (dynamicText) this._setSearchIndex("dynamic_text", "_", {
 			mappings: { dynamic: true },
@@ -732,73 +404,65 @@ else {
 			text: { fuzzy: { maxEdits: textSearch.fuzzy || 0 } }
 		});
 	}
-	get uniqueProps() {
-		return this._uniqueProps;
-	}
-	_finalizeIndexesForCollection() {
-		for (const [key, value] of Array.from(this._vectorFilters.entries())) {
-			const index = this._indexes.get(key);
-			if (index && index.type === "vector") index.definition.fields?.push({
-				type: "filter",
-				path: value
-			});
+	onFieldScanned(field, type, metadata) {
+		if (field !== "_id" && metadata.has("meta.id")) {
+			this._table.removePrimaryKey(field);
+			this._addMongoIndexField("unique", "__pk", field);
+			this._table.addUniqueField(field);
 		}
-		for (const [, value] of Array.from(this._indexes.entries())) if (value.type === "unique") {
-			const keys = Object.keys(value.fields);
-			if (keys.length === 1) this._uniqueProps.add(keys[0]);
-		}
-	}
-	_prepareIndexesForField(fieldName, metadata) {
-		for (const index of metadata.get("db.index.plain") || []) {
-			const name = index === true ? fieldName : index.name || fieldName;
-			this._addIndexField("plain", name, fieldName);
-		}
-		for (const index of metadata.get("db.index.unique") || []) {
-			const name = index === true ? fieldName : index.name || fieldName;
-			this._addIndexField("unique", name, fieldName);
+		const defaultFn = metadata.get("db.default.fn");
+		if (defaultFn === "increment") {
+			const physicalName = metadata.get("db.column") ?? field;
+			this._incrementFields.add(physicalName);
 		}
 		for (const index of metadata.get("db.index.fulltext") || []) {
 			const name = index === true ? "" : index.name || "";
-			this._addIndexField("text", name, fieldName, 1);
+			const weight = index !== true && typeof index === "object" ? index.weight || 1 : 1;
+			this._addMongoIndexField("text", name, field, weight);
 		}
-		const textWeight = metadata.get("db.mongo.index.text");
-		if (textWeight) this._addIndexField("text", "", fieldName, textWeight === true ? 1 : textWeight);
-		for (const index of metadata.get("db.mongo.search.text") || []) this._addFieldToSearchIndex("search_text", index.indexName, fieldName, index.analyzer);
+		for (const index of metadata.get("db.mongo.search.text") || []) this._addFieldToSearchIndex("search_text", index.indexName, field, index.analyzer);
 		const vectorIndex = metadata.get("db.mongo.search.vector");
-		if (vectorIndex) this._setSearchIndex("vector", vectorIndex.indexName || fieldName, { fields: [{
+		if (vectorIndex) this._setSearchIndex("vector", vectorIndex.indexName || field, { fields: [{
 			type: "vector",
-			path: fieldName,
+			path: field,
 			similarity: vectorIndex.similarity || "dotProduct",
 			numDimensions: vectorIndex.dimensions
 		}] });
-		for (const index of metadata.get("db.mongo.search.filter") || []) this._vectorFilters.set(indexKey("vector", index.indexName), fieldName);
-	}
-	_flatten() {
-		if (!this._flatMap) {
-			this._prepareIndexesForCollection();
-			this._flatMap = flattenAnnotatedType(this.type, {
-				topLevelArrayTag: "db.mongo.__topLevelArray",
-				excludePhantomTypes: true,
-				onField: (path, _type, metadata) => this._prepareIndexesForField(path, metadata)
+		for (const index of metadata.get("db.mongo.search.filter") || []) this._vectorFilters.set(mongoIndexKey("vector", index.indexName), field);
+	}
+	onAfterFlatten() {
+		this._table.addPrimaryKey("_id");
+		for (const [key, value] of this._vectorFilters.entries()) {
+			const index = this._mongoIndexes.get(key);
+			if (index && index.type === "vector") index.definition.fields?.push({
+				type: "filter",
+				path: value
 			});
-			this._finalizeIndexesForCollection();
 		}
 	}
-	getSearchIndexes() {
+	/** Returns MongoDB-specific search index map (internal). */ getMongoSearchIndexes() {
 		if (!this._searchIndexesMap) {
+			this._table.flatMap;
 			this._searchIndexesMap = new Map();
-			let deafultIndex;
-			for (const index of this.indexes.values()) switch (index.type) {
+			let defaultIndex;
+			for (const index of this._table.indexes.values()) if (index.type === "fulltext" && !defaultIndex) defaultIndex = {
+				key: index.key,
+				name: index.name,
+				type: "text",
+				fields: Object.fromEntries(index.fields.map((f) => [f.name, "text"])),
+				weights: Object.fromEntries(index.fields.filter((f) => f.weight).map((f) => [f.name, f.weight]))
+			};
+			for (const index of this._mongoIndexes.values()) switch (index.type) {
 				case "text": {
-					if (!deafultIndex) deafultIndex = index;
+					if (!defaultIndex) defaultIndex = index;
 					break;
 				}
 				case "dynamic_text": {
-					deafultIndex = index;
+					defaultIndex = index;
 					break;
 				}
 				case "search_text": {
-					if (!deafultIndex || deafultIndex?.type === "text") deafultIndex = index;
+					if (!defaultIndex || defaultIndex.type === "text") defaultIndex = index;
 					this._searchIndexesMap.set(index.name, index);
 					break;
 				}
@@ -808,21 +472,231 @@ else {
 				}
 				default:
 			}
-			if (deafultIndex && !this._searchIndexesMap.has(DEFAULT_INDEX_NAME)) this._searchIndexesMap.set(DEFAULT_INDEX_NAME, deafultIndex);
+			if (defaultIndex && !this._searchIndexesMap.has(DEFAULT_INDEX_NAME)) this._searchIndexesMap.set(DEFAULT_INDEX_NAME, defaultIndex);
 		}
 		return this._searchIndexesMap;
 	}
-	getSearchIndex(name = DEFAULT_INDEX_NAME) {
-		return this.getSearchIndexes().get(name);
+	/** Returns a specific MongoDB search index by name. */ getMongoSearchIndex(name = DEFAULT_INDEX_NAME) {
+		return this.getMongoSearchIndexes().get(name);
+	}
+	/** Returns available search indexes as generic metadata for UI. */ getSearchIndexes() {
+		const mongoIndexes = this.getMongoSearchIndexes();
+		return [...mongoIndexes.entries()].map(([name, index]) => ({
+			name,
+			description: `${index.type} index`
+		}));
+	}
+	/**
+	* Builds a MongoDB `$search` pipeline stage.
+	* Override `buildVectorSearchStage` in subclasses to provide embeddings.
+	*/ buildSearchStage(text, indexName) {
+		const index = this.getMongoSearchIndex(indexName);
+		if (!index) return undefined;
+		if (index.type === "vector") return this.buildVectorSearchStage(text, index);
+		return { $search: {
+			index: index.key,
+			text: {
+				query: text,
+				path: { wildcard: "*" }
+			}
+		} };
+	}
+	/**
+	* Builds a vector search stage. Override in subclasses to generate embeddings.
+	* Returns `undefined` by default (vector search requires custom implementation).
+	*/ buildVectorSearchStage(text, index) {
+		return undefined;
+	}
+	async search(text, query, indexName) {
+		const searchStage = this.buildSearchStage(text, indexName);
+		if (!searchStage) throw new Error(indexName ? `Search index "${indexName}" not found` : "No search index available");
+		const filter = buildMongoFilter(query.filter);
+		const controls = query.controls || {};
+		const pipeline = [searchStage, { $match: filter }];
+		if (controls.$sort) pipeline.push({ $sort: controls.$sort });
+		if (controls.$skip) pipeline.push({ $skip: controls.$skip });
+		if (controls.$limit) pipeline.push({ $limit: controls.$limit });
+else pipeline.push({ $limit: 1e3 });
+		if (controls.$select) pipeline.push({ $project: controls.$select.asProjection });
+		return this.collection.aggregate(pipeline).toArray();
+	}
+	async searchWithCount(text, query, indexName) {
+		const searchStage = this.buildSearchStage(text, indexName);
+		if (!searchStage) throw new Error(indexName ? `Search index "${indexName}" not found` : "No search index available");
+		const filter = buildMongoFilter(query.filter);
+		const controls = query.controls || {};
+		const pipeline = [
+			searchStage,
+			{ $match: filter },
+			{ $facet: {
+				data: [
+					controls.$sort ? { $sort: controls.$sort } : undefined,
+					controls.$skip ? { $skip: controls.$skip } : undefined,
+					controls.$limit ? { $limit: controls.$limit } : undefined,
+					controls.$select ? { $project: controls.$select.asProjection } : undefined
+				].filter(Boolean),
+				meta: [{ $count: "count" }]
+			} }
+		];
+		const result = await this.collection.aggregate(pipeline).toArray();
+		return {
+			data: result[0]?.data || [],
+			count: result[0]?.meta[0]?.count || 0
+		};
+	}
+	async findManyWithCount(query) {
+		const filter = buildMongoFilter(query.filter);
+		const controls = query.controls || {};
+		const pipeline = [{ $match: filter }, { $facet: {
+			data: [
+				controls.$sort ? { $sort: controls.$sort } : undefined,
+				controls.$skip ? { $skip: controls.$skip } : undefined,
+				controls.$limit ? { $limit: controls.$limit } : undefined,
+				controls.$select ? { $project: controls.$select.asProjection } : undefined
+			].filter(Boolean),
+			meta: [{ $count: "count" }]
+		} }];
+		const result = await this.collection.aggregate(pipeline).toArray();
+		return {
+			data: result[0]?.data || [],
+			count: result[0]?.meta[0]?.count || 0
+		};
+	}
+	async collectionExists() {
+		if (this.asMongo) return this.asMongo.collectionExists(this._table.tableName);
+		const cols = await this.db.listCollections({ name: this._table.tableName }).toArray();
+		return cols.length > 0;
+	}
+	async ensureCollectionExists() {
+		const exists = await this.collectionExists();
+		if (!exists) await this.db.createCollection(this._table.tableName, { comment: "Created by Atscript Mongo Adapter" });
+	}
+	async insertOne(data) {
+		if (this._incrementFields.size > 0) {
+			const fields = this._fieldsNeedingIncrement(data);
+			if (fields.length > 0) {
+				const maxValues = await this._getMaxValues(fields);
+				for (const physical of fields) data[physical] = (maxValues.get(physical) ?? 0) + 1;
+			}
+		}
+		const result = await this.collection.insertOne(data);
+		return { insertedId: result.insertedId };
+	}
+	async insertMany(data) {
+		if (this._incrementFields.size > 0) {
+			const allFields = new Set();
+			for (const item of data) for (const f of this._fieldsNeedingIncrement(item)) allFields.add(f);
+			if (allFields.size > 0) {
+				const maxValues = await this._getMaxValues([...allFields]);
+				for (const item of data) for (const physical of allFields) if (item[physical] === undefined || item[physical] === null) {
+					const next = (maxValues.get(physical) ?? 0) + 1;
+					item[physical] = next;
+					maxValues.set(physical, next);
+				} else if (typeof item[physical] === "number") {
+					const current = maxValues.get(physical) ?? 0;
+					if (item[physical] > current) maxValues.set(physical, item[physical]);
+				}
+			}
+		}
+		const result = await this.collection.insertMany(data);
+		return {
+			insertedCount: result.insertedCount,
+			insertedIds: Object.values(result.insertedIds)
+		};
+	}
+	async findOne(query) {
+		const filter = buildMongoFilter(query.filter);
+		const opts = this._buildFindOptions(query.controls);
+		return this.collection.findOne(filter, opts);
 	}
-	get flatMap() {
-		this._flatten();
-		return this._flatMap;
+	async findMany(query) {
+		const filter = buildMongoFilter(query.filter);
+		const opts = this._buildFindOptions(query.controls);
+		return this.collection.find(filter, opts).toArray();
+	}
+	async count(query) {
+		const filter = buildMongoFilter(query.filter);
+		return this.collection.countDocuments(filter);
+	}
+	async updateOne(filter, data) {
+		const mongoFilter = buildMongoFilter(filter);
+		const result = await this.collection.updateOne(mongoFilter, { $set: data });
+		return {
+			matchedCount: result.matchedCount,
+			modifiedCount: result.modifiedCount
+		};
+	}
+	async replaceOne(filter, data) {
+		const mongoFilter = buildMongoFilter(filter);
+		const result = await this.collection.replaceOne(mongoFilter, data);
+		return {
+			matchedCount: result.matchedCount,
+			modifiedCount: result.modifiedCount
+		};
+	}
+	async deleteOne(filter) {
+		const mongoFilter = buildMongoFilter(filter);
+		const result = await this.collection.deleteOne(mongoFilter);
+		return { deletedCount: result.deletedCount };
+	}
+	async updateMany(filter, data) {
+		const mongoFilter = buildMongoFilter(filter);
+		const result = await this.collection.updateMany(mongoFilter, { $set: data });
+		return {
+			matchedCount: result.matchedCount,
+			modifiedCount: result.modifiedCount
+		};
+	}
+	async replaceMany(filter, data) {
+		const mongoFilter = buildMongoFilter(filter);
+		const result = await this.collection.updateMany(mongoFilter, { $set: data });
+		return {
+			matchedCount: result.matchedCount,
+			modifiedCount: result.modifiedCount
+		};
+	}
+	async deleteMany(filter) {
+		const mongoFilter = buildMongoFilter(filter);
+		const result = await this.collection.deleteMany(mongoFilter);
+		return { deletedCount: result.deletedCount };
+	}
+	async ensureTable() {
+		return this.ensureCollectionExists();
 	}
 	async syncIndexes() {
-		await this.ensureExists();
+		await this.ensureCollectionExists();
+		const allIndexes = new Map();
+		for (const [key, index] of this._table.indexes.entries()) {
+			const fields = {};
+			const weights = {};
+			let mongoType;
+			if (index.type === "fulltext") {
+				mongoType = "text";
+				for (const f of index.fields) {
+					fields[f.name] = "text";
+					if (f.weight) weights[f.name] = f.weight;
+				}
+			} else {
+				mongoType = index.type;
+				for (const f of index.fields) fields[f.name] = 1;
+			}
+			allIndexes.set(key, {
+				key,
+				name: index.name,
+				type: mongoType,
+				fields,
+				weights
+			});
+		}
+		for (const [key, index] of this._mongoIndexes.entries()) if (index.type === "text") {
+			const existing = allIndexes.get(key);
+			if (existing && existing.type === "text") {
+				Object.assign(existing.fields, index.fields);
+				Object.assign(existing.weights, index.weights);
+			} else allIndexes.set(key, index);
+		} else allIndexes.set(key, index);
 		const existingIndexes = await this.collection.listIndexes().toArray();
-		const indexesToCreate = new Map(this.indexes);
+		const indexesToCreate = new Map(allIndexes);
 		for (const remote of existingIndexes) {
 			if (!remote.name.startsWith(INDEX_PREFIX)) continue;
 			if (indexesToCreate.has(remote.name)) {
@@ -832,54 +706,21 @@ else {
 					case "unique":
 					case "text": {
 						if ((local.type === "text" || objMatch(local.fields, remote.key)) && objMatch(local.weights || {}, remote.weights || {})) indexesToCreate.delete(remote.name);
-else {
-							this.logger.debug(`dropping index "${remote.name}"`);
-							await this.collection.dropIndex(remote.name);
-						}
+else await this.collection.dropIndex(remote.name);
 						break;
 					}
 					default:
 				}
-			} else {
-				this.logger.debug(`dropping index "${remote.name}"`);
-				await this.collection.dropIndex(remote.name);
-			}
+			} else await this.collection.dropIndex(remote.name);
 		}
-		const toUpdate = new Set();
-		const existingSearchIndexes = await this.collection.listSearchIndexes().toArray();
-		for (const remote of existingSearchIndexes) {
-			if (!remote.name.startsWith(INDEX_PREFIX)) continue;
-			if (indexesToCreate.has(remote.name)) {
-				const local = indexesToCreate.get(remote.name);
-				const right = remote.latestDefinition;
-				switch (local.type) {
-					case "dynamic_text":
-					case "search_text": {
-						const left = local.definition;
-						if (left.analyzer === right.analyzer && fieldsMatch(left.mappings.fields || {}, right.mappings.fields || {})) indexesToCreate.delete(remote.name);
-else toUpdate.add(remote.name);
-						break;
-					}
-					case "vector": {
-						if (vectorFieldsMatch(local.definition.fields || [], right.fields || [])) indexesToCreate.delete(remote.name);
-else toUpdate.add(remote.name);
-						break;
-					}
-					default:
-				}
-			} else if (remote.status !== "DELETING") {
-				this.logger.debug(`dropping search index "${remote.name}"`);
-				await this.collection.dropSearchIndex(remote.name);
-			} else this.logger.debug(`search index "${remote.name}" is in deleting status`);
-		}
-		for (const [key, value] of Array.from(indexesToCreate.entries())) switch (value.type) {
+		for (const [key, value] of allIndexes.entries()) switch (value.type) {
 			case "plain": {
-				this.logger.debug(`creating index "${key}"`);
+				if (!indexesToCreate.has(key)) continue;
 				await this.collection.createIndex(value.fields, { name: key });
 				break;
 			}
 			case "unique": {
-				this.logger.debug(`creating index "${key}"`);
+				if (!indexesToCreate.has(key)) continue;
 				await this.collection.createIndex(value.fields, {
 					name: key,
 					unique: true
@@ -887,160 +728,168 @@ else toUpdate.add(remote.name);
 				break;
 			}
 			case "text": {
-				this.logger.debug(`creating index "${key}"`);
+				if (!indexesToCreate.has(key)) continue;
 				await this.collection.createIndex(value.fields, {
 					weights: value.weights,
 					name: key
 				});
 				break;
 			}
-			case "dynamic_text":
-			case "search_text":
-			case "vector": {
-				if (toUpdate.has(key)) {
-					this.logger.debug(`updating search index "${key}"`);
-					await this.collection.updateSearchIndex(key, value.definition);
-				} else {
-					this.logger.debug(`creating search index "${key}"`);
-					await this.collection.createSearchIndex({
+			default:
+		}
+		try {
+			const toUpdate = new Set();
+			const existingSearchIndexes = await this.collection.listSearchIndexes().toArray();
+			for (const remote of existingSearchIndexes) {
+				if (!remote.name.startsWith(INDEX_PREFIX)) continue;
+				if (indexesToCreate.has(remote.name)) {
+					const local = indexesToCreate.get(remote.name);
+					const right = remote.latestDefinition;
+					switch (local.type) {
+						case "dynamic_text":
+						case "search_text": {
+							const left = local.definition;
+							if (left.analyzer === right.analyzer && fieldsMatch(left.mappings.fields || {}, right.mappings.fields || {})) indexesToCreate.delete(remote.name);
+else toUpdate.add(remote.name);
+							break;
+						}
+						case "vector": {
+							if (vectorFieldsMatch(local.definition.fields || [], right.fields || [])) indexesToCreate.delete(remote.name);
+else toUpdate.add(remote.name);
+							break;
+						}
+						default:
+					}
+				} else if (remote.status !== "DELETING") await this.collection.dropSearchIndex(remote.name);
+			}
+			for (const [key, value] of indexesToCreate.entries()) switch (value.type) {
+				case "dynamic_text":
+				case "search_text":
+				case "vector": {
+					if (toUpdate.has(key)) await this.collection.updateSearchIndex(key, value.definition);
+else await this.collection.createSearchIndex({
 						name: key,
 						type: value.type === "vector" ? "vectorSearch" : "search",
 						definition: value.definition
 					});
+					break;
 				}
-				break;
+				default:
+			}
+		} catch {}
+	}
+	/** Returns physical field names of increment fields that are undefined in the data. */ _fieldsNeedingIncrement(data) {
+		const result = [];
+		for (const physical of this._incrementFields) if (data[physical] === undefined || data[physical] === null) result.push(physical);
+		return result;
+	}
+	/** Reads current max value for each field via $group aggregation. */ async _getMaxValues(physicalFields) {
+		const aliases = physicalFields.map((f) => [`max__${f.replace(/\./g, "__")}`, f]);
+		const group = { _id: null };
+		for (const [alias, field] of aliases) group[alias] = { $max: `$${field}` };
+		const result = await this.collection.aggregate([{ $group: group }]).toArray();
+		const maxMap = new Map();
+		if (result.length > 0) {
+			const row = result[0];
+			for (const [alias, field] of aliases) {
+				const val = row[alias];
+				maxMap.set(field, typeof val === "number" ? val : 0);
 			}
-			default:
 		}
+		return maxMap;
+	}
+	_buildFindOptions(controls) {
+		const opts = {};
+		if (!controls) return opts;
+		if (controls.$sort) opts.sort = controls.$sort;
+		if (controls.$limit) opts.limit = controls.$limit;
+		if (controls.$skip) opts.skip = controls.$skip;
+		if (controls.$select) opts.projection = controls.$select.asProjection;
+		return opts;
+	}
+	_addMongoIndexField(type, name, field, weight) {
+		const key = mongoIndexKey(type, name);
+		let index = this._mongoIndexes.get(key);
+		const value = type === "text" ? "text" : 1;
+		if (index) index.fields[field] = value;
+else {
+			index = {
+				key,
+				name,
+				type,
+				fields: { [field]: value },
+				weights: {}
+			};
+			this._mongoIndexes.set(key, index);
+		}
+		if (weight) index.weights[field] = weight;
 	}
-	insert(payload, options) {
-		const toInsert = this.prepareInsert(payload);
-		return Array.isArray(toInsert) ? this.collection.insertMany(toInsert, options) : this.collection.insertOne(toInsert, options);
-	}
-	replace(payload, options) {
-		const [filter, replace, opts] = this.prepareReplace(payload).toArgs();
-		return this.collection.replaceOne(filter, replace, {
-			...opts,
-			...options
-		});
-	}
-	update(payload, options) {
-		const [filter, update, opts] = this.prepareUpdate(payload).toArgs();
-		return this.collection.updateOne(filter, update, {
-			...opts,
-			...options
+	_setSearchIndex(type, name, definition) {
+		const key = mongoIndexKey(type, name || DEFAULT_INDEX_NAME);
+		this._mongoIndexes.set(key, {
+			key,
+			name: name || DEFAULT_INDEX_NAME,
+			type,
+			definition
 		});
 	}
-	prepareInsert(payload) {
-		const v = this.getValidator("insert");
-		const arr = Array.isArray(payload) ? payload : [payload];
-		const prepared = [];
-		for (const item of arr) if (v.validate(item)) {
-			const data = { ...item };
-			if (data._id) data._id = this.prepareId(data._id);
-else if (this.idType !== "objectId") throw new Error("Missing \"_id\" field");
-			prepared.push(data);
-		} else throw new Error("Invalid payload");
-		return prepared.length === 1 ? prepared[0] : prepared;
-	}
-	prepareReplace(payload) {
-		const v = this.getValidator("update");
-		if (v.validate(payload)) {
-			const _id = this.prepareId(payload._id);
-			const data = {
-				...payload,
-				_id
-			};
-			return {
-				toArgs: () => [
-					{ _id },
-					data,
-					{}
-				],
-				filter: { _id },
-				updateFilter: data,
-				updateOptions: {}
-			};
+	_addFieldToSearchIndex(type, _name, fieldName, analyzer) {
+		const name = _name || DEFAULT_INDEX_NAME;
+		let index = this._mongoIndexes.get(mongoIndexKey(type, name));
+		if (!index && type === "search_text") {
+			this._setSearchIndex(type, name, {
+				mappings: { fields: {} },
+				text: { fuzzy: { maxEdits: 0 } }
+			});
+			index = this._mongoIndexes.get(mongoIndexKey(type, name));
 		}
-		throw new Error("Invalid payload");
-	}
-	prepareUpdate(payload) {
-		const v = this.getValidator("patch");
-		if (v.validate(payload)) return new CollectionPatcher(this, payload).preparePatch();
-		throw new Error("Invalid payload");
-	}
-	constructor(asMongo, _type, logger = NoopLogger) {
-		_define_property$1(this, "asMongo", void 0);
-		_define_property$1(this, "_type", void 0);
-		_define_property$1(this, "logger", void 0);
-		_define_property$1(this, "name", void 0);
-		_define_property$1(this, "collection", void 0);
-		_define_property$1(this, "validators", void 0);
-		_define_property$1(this, "_indexes", void 0);
-		_define_property$1(this, "_vectorFilters", void 0);
-		_define_property$1(this, "_flatMap", void 0);
-		_define_property$1(this, "_uniqueProps", void 0);
-		_define_property$1(this, "_searchIndexesMap", void 0);
-		this.asMongo = asMongo;
-		this._type = _type;
-		this.logger = logger;
-		this.validators = new Map();
-		this._indexes = new Map();
-		this._vectorFilters = new Map();
-		this._uniqueProps = new Set();
-		if (!isAnnotatedType(_type)) throw new Error("Atscript Annotated Type expected");
-		const name = _type.metadata.get("db.table");
-		if (!name) throw new Error("@db.table annotation expected with collection name");
-		if (_type.type.kind !== "object") throw new Error("Mongo collection must be an object type");
-		this.name = name;
-		this.collection = asMongo.db.collection(name);
+		if (index) {
+			index.definition.mappings.fields[fieldName] = { type: "string" };
+			if (analyzer) index.definition.mappings.fields[fieldName].analyzer = analyzer;
+		}
+	}
+	constructor(db, asMongo) {
+		super(), _define_property$1(this, "db", void 0), _define_property$1(this, "asMongo", void 0), _define_property$1(this, "_collection", void 0), _define_property$1(this, "_mongoIndexes", void 0), _define_property$1(this, "_vectorFilters", void 0), _define_property$1(this, "_searchIndexesMap", void 0), _define_property$1(this, "_incrementFields", void 0), this.db = db, this.asMongo = asMongo, this._mongoIndexes = new Map(), this._vectorFilters = new Map(), this._incrementFields = new Set();
 	}
 };
-/**
-* Vector Index fields matching
-*/ function vectorFieldsMatch(left, right) {
-	const leftMap = new Map();
-	left.forEach((f) => leftMap.set(f.path, f));
-	const rightMap = new Map();
-	(right || []).forEach((f) => rightMap.set(f.path, f));
-	if (leftMap.size === rightMap.size) {
-		let match = true;
-		for (const [key, left$1] of leftMap.entries()) {
-			const right$1 = rightMap.get(key);
-			if (!right$1) {
-				match = false;
-				break;
-			}
-			if (left$1.type === right$1.type && left$1.path === right$1.path && left$1.similarity === right$1.similarity && left$1.numDimensions === right$1.numDimensions) continue;
-			match = false;
-			break;
-		}
-		return match;
-	} else return false;
+function objMatch(o1, o2) {
+	const keys1 = Object.keys(o1);
+	const keys2 = Object.keys(o2);
+	if (keys1.length !== keys2.length) return false;
+	return keys1.every((key) => o1[key] === o2[key]);
 }
-/**
-* Search Index fields matching
-*/ function fieldsMatch(left, right) {
+function fieldsMatch(left, right) {
 	if (!left || !right) return left === right;
 	const leftKeys = Object.keys(left);
 	const rightKeys = Object.keys(right);
 	if (leftKeys.length !== rightKeys.length) return false;
 	return leftKeys.every((key) => {
 		if (!(key in right)) return false;
-		const leftField = left[key];
-		const rightField = right[key];
-		return leftField.type === rightField.type && leftField.analyzer === rightField.analyzer;
+		return left[key].type === right[key].type && left[key].analyzer === right[key].analyzer;
 	});
 }
-/**
-* Shallow object matching
-*/ function objMatch(o1, o2) {
-	const keys1 = Object.keys(o1);
-	const keys2 = Object.keys(o2);
-	if (keys1.length !== keys2.length) return false;
-	return keys1.every((key) => o1[key] === o2[key]);
+function vectorFieldsMatch(left, right) {
+	const leftMap = new Map(left.map((f) => [f.path, f]));
+	const rightMap = new Map((right || []).map((f) => [f.path, f]));
+	if (leftMap.size !== rightMap.size) return false;
+	for (const [key, l] of leftMap.entries()) {
+		const r = rightMap.get(key);
+		if (!r) return false;
+		if (l.type !== r.type || l.path !== r.path || l.similarity !== r.similarity || l.numDimensions !== r.numDimensions) return false;
+	}
+	return true;
 }
 
+//#endregion
+//#region packages/mongo/src/lib/logger.ts
+const NoopLogger = {
+	error: () => {},
+	warn: () => {},
+	log: () => {},
+	info: () => {},
+	debug: () => {}
+};
+
 //#endregion
 //#region packages/mongo/src/lib/as-mongo.ts
 function _define_property(obj, key, value) {
@@ -1065,25 +914,35 @@ var AsMongo = class {
 		const list = await this.getCollectionsList();
 		return list.has(name);
 	}
-	getCollection(type, logger) {
-		let collection = this._collections.get(type);
-		if (!collection) {
-			collection = new AsCollection(this, type, logger || this.logger);
-			this._collections.set(type, collection);
+	getAdapter(type) {
+		this._ensureCreated(type);
+		return this._adapters.get(type);
+	}
+	getTable(type, logger) {
+		this._ensureCreated(type, logger);
+		return this._tables.get(type);
+	}
+	_ensureCreated(type, logger) {
+		if (!this._adapters.has(type)) {
+			const adapter = new MongoAdapter(this.db, this);
+			const table = new AtscriptDbTable(type, adapter, logger || this.logger);
+			this._adapters.set(type, adapter);
+			this._tables.set(type, table);
 		}
-		return collection;
 	}
 	constructor(client, logger = NoopLogger) {
 		_define_property(this, "logger", void 0);
 		_define_property(this, "client", void 0);
 		_define_property(this, "collectionsList", void 0);
-		_define_property(this, "_collections", void 0);
+		_define_property(this, "_adapters", void 0);
+		_define_property(this, "_tables", void 0);
 		this.logger = logger;
-		this._collections = new WeakMap();
+		this._adapters = new WeakMap();
+		this._tables = new WeakMap();
 		if (typeof client === "string") this.client = new MongoClient(client);
 else this.client = client;
 	}
 };
 
 //#endregion
-export { AsCollection, AsMongo, MongoPlugin };
+export { AsMongo, CollectionPatcher, MongoAdapter, buildMongoFilter, validateMongoIdPlugin };