@atscript/mongo 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Atscript
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,611 @@
+"use strict";
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const __atscript_core = __toESM(require("@atscript/core"));
+const __atscript_typescript = __toESM(require("@atscript/typescript"));
+const mongodb = __toESM(require("mongodb"));
+
+//#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"
+	},
+	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/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 = { mongo: {
+	collection: new __atscript_core.AnnotationSpec({
+		description: "Defines a **MongoDB collection**. This annotation is required to mark an interface as a collection.\n\n- Automatically enforces a **non-optional** `_id` field.\n- `_id` must be of type **`string`**, **`number`**, or **`mongo.objectId`**.\n- Ensures that `_id` is included if not explicitly defined.\n\n**Example:**\n```atscript\n@mongo.collection \"users\"\nexport interface User {\n    _id: mongo.objectId\n    email: string.email\n}\n```\n",
+		nodeType: ["interface"],
+		argument: {
+			name: "name",
+			type: "string",
+			description: "The **name of the MongoDB collection**."
+		},
+		validate(token, args, doc) {
+			const parent = token.parentNode;
+			const struc = parent?.getDefinition();
+			const errors = [];
+			if ((0, __atscript_core.isInterface)(parent) && parent.props.has("_id") && (0, __atscript_core.isStructure)(struc)) {
+				const _id = parent.props.get("_id");
+				const isOptional = !!_id.token("optional");
+				if (isOptional) errors.push({
+					message: `[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 ((0, __atscript_core.isRef)(definition)) {
+					const def = doc.unwindType(definition.id, definition.chain)?.def;
+					if ((0, __atscript_core.isPrimitive)(def) && !["string", "number"].includes(def.config.type)) wrongType = true;
+				} else wrongType = true;
+				if (wrongType) errors.push({
+					message: `[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 ((0, __atscript_core.isInterface)(parent) && !parent.props.has("_id") && (0, __atscript_core.isStructure)(struc)) struc.addVirtualProp({
+				name: "_id",
+				type: "mongo.objectId",
+				documentation: "Mongodb Primary Key ObjectId"
+			});
+		}
+	}),
+	index: {
+		plain: new __atscript_core.AnnotationSpec({
+			description: "Defines a **standard MongoDB index** on a field.\n\n- Improves query performance on indexed fields.\n- Can be used for **single-field** or **compound** indexes.\n\n**Example:**\n```atscript\n@mongo.index.plain \"departmentIndex\"\ndepartment: string\n```\n",
+			multiple: true,
+			nodeType: ["prop"],
+			argument: {
+				optional: true,
+				name: "indexName",
+				type: "string",
+				description: "The **name of the index** (optional). If omitted, property name is used."
+			}
+		}),
+		unique: new __atscript_core.AnnotationSpec({
+			description: "Creates a **unique index** on a field to ensure no duplicate values exist.\n\n- Enforces uniqueness at the database level.\n- Automatically prevents duplicate entries.\n- Typically used for **emails, usernames, and IDs**.\n\n**Example:**\n```atscript\n@mongo.index.unique \"uniqueEmailIndex\"\nemail: string.email\n```\n",
+			multiple: true,
+			nodeType: ["prop"],
+			argument: {
+				optional: true,
+				name: "indexName",
+				type: "string",
+				description: "The **name of the unique index** (optional). If omitted, property name is used."
+			}
+		}),
+		text: new __atscript_core.AnnotationSpec({
+			description: "Creates a **legacy MongoDB text index** for full-text search.\n\n**⚠ WARNING:** *Text indexes slow down database operations. Use `@mongo.defineTextSearch` instead for better performance.*\n\n- Allows **basic full-text search** on a field.\n- Does **not support fuzzy matching or ranking**.\n- **Replaced by MongoDB Atlas Search Indexes (`@mongo.searchIndex.text`).**\n\n**Example:**\n```atscript\n@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 __atscript_core.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@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 __atscript_core.AnnotationSpec({
+			description: "Defines a **MongoDB Atlas Search Index** for the collection. The props can refer to this index using `@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 `@mongo.useTextSearch`** to be included in this search index.\n\n**Example:**\n```atscript\n@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 `@mongo.search.text`. If not set, defaults to `\"DEFAULT\"`."
+				}
+			]
+		}),
+		text: new __atscript_core.AnnotationSpec({
+			description: "Marks a field to be **included in a MongoDB Atlas Search Index** defined by `@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@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 `@mongo.defineTextSearch`. This links the field to the correct index. If not set, defaults to `\"DEFAULT\"`."
+			}]
+		}),
+		vector: new __atscript_core.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@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 __atscript_core.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 `@mongo.search.vector`.\n\n**Example:**\n```atscript\n@mongo.search.vector 512, \"cosine\"\nembedding: number[]\n\n@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."
+			}]
+		})
+	}
+} };
+
+//#endregion
+//#region packages/mongo/src/plugin/index.ts
+const MongoPlugin = () => {
+	return {
+		name: "mongo",
+		config() {
+			return {
+				primitives,
+				annotations
+			};
+		}
+	};
+};
+
+//#endregion
+//#region packages/mongo/src/lib/logger.ts
+const NoopLogger = {
+	error: () => {},
+	warn: () => {},
+	log: () => {},
+	info: () => {},
+	debug: () => {}
+};
+
+//#endregion
+//#region packages/mongo/src/lib/as-collection.ts
+function _define_property$1(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+else obj[key] = value;
+	return obj;
+}
+const INDEX_PREFIX = "anscript__";
+const DEFAULT_INDEX_NAME = "DEFAULT";
+function indexKey(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 {
+	async exists() {
+		return this.asMongo.collectionExists(this.name);
+	}
+	async ensureExists() {
+		const exists = await this.exists();
+		if (!exists) await this.asMongo.db.createCollection(this.name, { comment: "Created by Atscript Mongo Collection" });
+	}
+	get type() {
+		return this._type;
+	}
+	get indexes() {
+		this._flatten();
+		return this._indexes;
+	}
+	_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 = {
+				type,
+				fields: { [field]: value },
+				weights
+			};
+			this._indexes.set(key, index);
+		}
+		if (weight) index.weights[field] = weight;
+	}
+	_setSearchIndex(type, name, definition) {
+		this._indexes.set(indexKey(type, name || DEFAULT_INDEX_NAME), {
+			type,
+			definition
+		});
+	}
+	_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;
+		}
+	}
+	_flattenType(type, prefix) {
+		switch (type.type.kind) {
+			case "object":
+				const items = Array.from(type.type.props.entries());
+				for (const [key, value] of items) this._flattenType(value, prefix ? `${prefix}.${key}` : key);
+				break;
+			case "array":
+				this._flattenType(type.type.of, prefix);
+				break;
+			case "intersection":
+			case "tuple":
+			case "union": for (const item of type.type.items) this._flattenType(item, prefix);
+			default:
+				this._flatMap?.set(prefix || "", type);
+				break;
+		}
+		if (prefix) this._prepareIndexesForField(prefix, type.metadata);
+	}
+	_prepareIndexesForCollection() {
+		const typeMeta = this.type.metadata;
+		const dynamicText = typeMeta.get("mongo.search.dynamic");
+		if (dynamicText) this._setSearchIndex("dynamic_text", "_", {
+			mappings: { dynamic: true },
+			analyzer: dynamicText.analyzer,
+			text: { fuzzy: { maxEdits: dynamicText.fuzzy || 0 } }
+		});
+		for (const textSearch of typeMeta.get("mongo.search.static") || []) this._setSearchIndex("search_text", textSearch.indexName, {
+			mappings: { fields: {} },
+			analyzer: textSearch.analyzer,
+			text: { fuzzy: { maxEdits: textSearch.fuzzy || 0 } }
+		});
+	}
+	_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
+			});
+		}
+	}
+	_prepareIndexesForField(fieldName, metadata) {
+		for (const index of metadata.get("mongo.index.plain") || []) this._addIndexField("plain", index === true ? fieldName : index, fieldName);
+		for (const index of metadata.get("mongo.index.unique") || []) this._addIndexField("unique", index === true ? fieldName : index, fieldName);
+		const textWeight = metadata.get("mongo.index.text");
+		if (textWeight) this._addIndexField("text", "", fieldName, textWeight === true ? 1 : textWeight);
+		for (const index of metadata.get("mongo.search.text") || []) this._addFieldToSearchIndex("search_text", index.indexName, fieldName, index.analyzer);
+		const vectorIndex = metadata.get("mongo.search.vector");
+		if (vectorIndex) this._setSearchIndex("vector", vectorIndex.indexName || fieldName, { fields: [{
+			type: "vector",
+			path: fieldName,
+			similarity: vectorIndex.similarity || "dotProduct",
+			numDimensions: vectorIndex.dimensions
+		}] });
+		for (const index of metadata.get("mongo.search.filter") || []) this._vectorFilters.set(indexKey("vector", index.indexName), fieldName);
+	}
+	_flatten() {
+		if (!this._flatMap) {
+			this._flatMap = new Map();
+			this._prepareIndexesForCollection();
+			this._flattenType(this.type);
+			this._finalizeIndexesForCollection();
+		}
+	}
+	get flatMap() {
+		this._flatten();
+		return this._flatMap;
+	}
+	async syncIndexes() {
+		await this.ensureExists();
+		const existingIndexes = await this.collection.listIndexes().toArray();
+		const indexesToCreate = new Map(this.indexes);
+		for (const remote of existingIndexes) {
+			if (!remote.name.startsWith(INDEX_PREFIX)) continue;
+			if (indexesToCreate.has(remote.name)) {
+				const local = indexesToCreate.get(remote.name);
+				switch (local.type) {
+					case "plain":
+					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);
+						}
+						break;
+					default:
+				}
+			} else {
+				this.logger.debug(`dropping index "${remote.name}"`);
+				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":
+						let 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) {
+			case "plain":
+				this.logger.debug(`creating index "${key}"`);
+				await this.collection.createIndex(value.fields, { name: key });
+				break;
+			case "unique":
+				this.logger.debug(`creating index "${key}"`);
+				await this.collection.createIndex(value.fields, {
+					name: key,
+					unique: true
+				});
+				break;
+			case "text":
+				this.logger.debug(`creating index "${key}"`);
+				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({
+						name: key,
+						type: value.type === "vector" ? "vectorSearch" : "search",
+						definition: value.definition
+					});
+				}
+				break;
+			default:
+		}
+	}
+	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, "_indexes", void 0);
+		_define_property$1(this, "_vectorFilters", void 0);
+		_define_property$1(this, "_flatMap", void 0);
+		this.asMongo = asMongo;
+		this._type = _type;
+		this.logger = logger;
+		this._indexes = new Map();
+		this._vectorFilters = new Map();
+		if (!(0, __atscript_typescript.isAnnotatedType)(_type)) throw new Error("Atscript Annotated Type expected");
+		const name = _type.metadata.get("mongo.collection");
+		if (!name) throw new Error("@mongo.collection 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);
+	}
+};
+/**
+* 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;
+}
+/**
+* Search Index fields matching
+*/ 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;
+	});
+}
+/**
+* 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]);
+}
+
+//#endregion
+//#region packages/mongo/src/lib/as-mongo.ts
+function _define_property(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+else obj[key] = value;
+	return obj;
+}
+var AsMongo = class {
+	get db() {
+		return this.client.db();
+	}
+	getCollectionsList() {
+		if (!this.collectionsList) this.collectionsList = this.db.listCollections().toArray().then((c) => new Set(c.map((c$1) => c$1.name)));
+		return this.collectionsList;
+	}
+	async collectionExists(name) {
+		const list = await this.getCollectionsList();
+		return list.has(name);
+	}
+	getCollection(type, logger) {
+		return new AsCollection(this, type, logger || this.logger);
+	}
+	constructor(client, logger = NoopLogger) {
+		_define_property(this, "logger", void 0);
+		_define_property(this, "client", void 0);
+		_define_property(this, "collectionsList", void 0);
+		this.logger = logger;
+		if (typeof client === "string") this.client = new mongodb.MongoClient(client);
+else this.client = client;
+	}
+};
+
+//#endregion
+exports.AsCollection = AsCollection
+exports.AsMongo = AsMongo
+exports.MongoPlugin = MongoPlugin

package/dist/index.d.ts

@@ -0,0 +1,85 @@
+import { TAtscriptPlugin } from '@atscript/core';
+import { TAtscriptAnnotatedType, TAtscriptTypeObject, TMetadataMap } from '@atscript/typescript';
+import * as mongodb from 'mongodb';
+import { MongoClient, Collection } from 'mongodb';
+
+declare const MongoPlugin: () => TAtscriptPlugin;
+
+interface TGenericLogger {
+    error(...messages: any[]): void;
+    warn(...messages: any[]): void;
+    log(...messages: any[]): void;
+    info(...messages: any[]): void;
+    debug(...messages: any[]): void;
+}
+
+declare class AsMongo {
+    protected readonly logger: TGenericLogger;
+    readonly client: MongoClient;
+    constructor(client: string | MongoClient, logger?: TGenericLogger);
+    get db(): mongodb.Db;
+    protected collectionsList?: Promise<Set<string>>;
+    protected getCollectionsList(): Promise<Set<string>>;
+    collectionExists(name: string): Promise<boolean>;
+    getCollection<T extends TAtscriptAnnotatedType & (new (...args: any[]) => any)>(type: T, logger?: TGenericLogger): AsCollection<T>;
+}
+
+type TPlainIndex = {
+    type: 'plain' | 'unique' | 'text';
+    fields: Record<string, 1 | 'text'>;
+    weights: Record<string, number>;
+};
+type TSearchIndex = {
+    type: 'dynamic_text' | 'search_text' | 'vector';
+    definition: TMongoSearchIndexDefinition;
+};
+type TIndex = TPlainIndex | TSearchIndex;
+declare class AsCollection<T extends TAtscriptAnnotatedType & (new (...args: any[]) => any)> {
+    protected readonly asMongo: AsMongo;
+    protected readonly _type: T;
+    protected readonly logger: TGenericLogger;
+    readonly name: string;
+    readonly collection: Collection<InstanceType<T>>;
+    constructor(asMongo: AsMongo, _type: T, logger?: TGenericLogger);
+    exists(): Promise<boolean>;
+    ensureExists(): Promise<void>;
+    get type(): TAtscriptAnnotatedType<TAtscriptTypeObject>;
+    protected _indexes: Map<string, TIndex>;
+    protected _vectorFilters: Map<string, string>;
+    get indexes(): Map<string, TIndex>;
+    protected _addIndexField(type: TPlainIndex['type'], name: string, field: string, weight?: number): void;
+    protected _setSearchIndex(type: TSearchIndex['type'], name: string | undefined, definition: TMongoSearchIndexDefinition): void;
+    protected _addFieldToSearchIndex(type: TSearchIndex['type'], _name: string | undefined, fieldName: string, analyzer?: string): void;
+    protected _flatMap?: Map<string, TAtscriptAnnotatedType>;
+    protected _flattenType(type: TAtscriptAnnotatedType, prefix?: string): void;
+    protected _prepareIndexesForCollection(): void;
+    protected _finalizeIndexesForCollection(): void;
+    protected _prepareIndexesForField(fieldName: string, metadata: TMetadataMap<AtscriptMetadata>): void;
+    protected _flatten(): void;
+    get flatMap(): Map<string, TAtscriptAnnotatedType> | undefined;
+    syncIndexes(): Promise<void>;
+}
+type TVectorSimilarity = 'cosine' | 'euclidean' | 'dotProduct';
+type TMongoSearchIndexDefinition = {
+    mappings?: {
+        dynamic?: boolean;
+        fields?: Record<string, {
+            type: 'string' | 'number' | 'boolean' | 'date' | 'object' | 'array';
+            analyzer?: string;
+        }>;
+    };
+    fields?: {
+        path: string;
+        type: 'filter' | 'vector';
+        similarity?: TVectorSimilarity;
+        numDimensions?: number;
+    }[];
+    analyzer?: string;
+    text?: {
+        fuzzy?: {
+            maxEdits: number;
+        };
+    };
+};
+
+export { AsCollection, AsMongo, MongoPlugin };

package/dist/index.mjs

@@ -0,0 +1,585 @@
+import { AnnotationSpec, isInterface, isPrimitive, isRef, isStructure } from "@atscript/core";
+import { isAnnotatedType } from "@atscript/typescript";
+import { MongoClient } from "mongodb";
+
+//#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"
+	},
+	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/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 = { mongo: {
+	collection: new AnnotationSpec({
+		description: "Defines a **MongoDB collection**. This annotation is required to mark an interface as a collection.\n\n- Automatically enforces a **non-optional** `_id` field.\n- `_id` must be of type **`string`**, **`number`**, or **`mongo.objectId`**.\n- Ensures that `_id` is included if not explicitly defined.\n\n**Example:**\n```atscript\n@mongo.collection \"users\"\nexport interface User {\n    _id: mongo.objectId\n    email: string.email\n}\n```\n",
+		nodeType: ["interface"],
+		argument: {
+			name: "name",
+			type: "string",
+			description: "The **name of the MongoDB collection**."
+		},
+		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: `[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: `[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"
+			});
+		}
+	}),
+	index: {
+		plain: new AnnotationSpec({
+			description: "Defines a **standard MongoDB index** on a field.\n\n- Improves query performance on indexed fields.\n- Can be used for **single-field** or **compound** indexes.\n\n**Example:**\n```atscript\n@mongo.index.plain \"departmentIndex\"\ndepartment: string\n```\n",
+			multiple: true,
+			nodeType: ["prop"],
+			argument: {
+				optional: true,
+				name: "indexName",
+				type: "string",
+				description: "The **name of the index** (optional). If omitted, property name is used."
+			}
+		}),
+		unique: new AnnotationSpec({
+			description: "Creates a **unique index** on a field to ensure no duplicate values exist.\n\n- Enforces uniqueness at the database level.\n- Automatically prevents duplicate entries.\n- Typically used for **emails, usernames, and IDs**.\n\n**Example:**\n```atscript\n@mongo.index.unique \"uniqueEmailIndex\"\nemail: string.email\n```\n",
+			multiple: true,
+			nodeType: ["prop"],
+			argument: {
+				optional: true,
+				name: "indexName",
+				type: "string",
+				description: "The **name of the unique index** (optional). If omitted, property name is used."
+			}
+		}),
+		text: new AnnotationSpec({
+			description: "Creates a **legacy MongoDB text index** for full-text search.\n\n**⚠ WARNING:** *Text indexes slow down database operations. Use `@mongo.defineTextSearch` instead for better performance.*\n\n- Allows **basic full-text search** on a field.\n- Does **not support fuzzy matching or ranking**.\n- **Replaced by MongoDB Atlas Search Indexes (`@mongo.searchIndex.text`).**\n\n**Example:**\n```atscript\n@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@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 `@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 `@mongo.useTextSearch`** to be included in this search index.\n\n**Example:**\n```atscript\n@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 `@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 `@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@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 `@mongo.defineTextSearch`. 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@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 `@mongo.search.vector`.\n\n**Example:**\n```atscript\n@mongo.search.vector 512, \"cosine\"\nembedding: number[]\n\n@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."
+			}]
+		})
+	}
+} };
+
+//#endregion
+//#region packages/mongo/src/plugin/index.ts
+const MongoPlugin = () => {
+	return {
+		name: "mongo",
+		config() {
+			return {
+				primitives,
+				annotations
+			};
+		}
+	};
+};
+
+//#endregion
+//#region packages/mongo/src/lib/logger.ts
+const NoopLogger = {
+	error: () => {},
+	warn: () => {},
+	log: () => {},
+	info: () => {},
+	debug: () => {}
+};
+
+//#endregion
+//#region packages/mongo/src/lib/as-collection.ts
+function _define_property$1(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+else obj[key] = value;
+	return obj;
+}
+const INDEX_PREFIX = "anscript__";
+const DEFAULT_INDEX_NAME = "DEFAULT";
+function indexKey(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 {
+	async exists() {
+		return this.asMongo.collectionExists(this.name);
+	}
+	async ensureExists() {
+		const exists = await this.exists();
+		if (!exists) await this.asMongo.db.createCollection(this.name, { comment: "Created by Atscript Mongo Collection" });
+	}
+	get type() {
+		return this._type;
+	}
+	get indexes() {
+		this._flatten();
+		return this._indexes;
+	}
+	_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 = {
+				type,
+				fields: { [field]: value },
+				weights
+			};
+			this._indexes.set(key, index);
+		}
+		if (weight) index.weights[field] = weight;
+	}
+	_setSearchIndex(type, name, definition) {
+		this._indexes.set(indexKey(type, name || DEFAULT_INDEX_NAME), {
+			type,
+			definition
+		});
+	}
+	_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;
+		}
+	}
+	_flattenType(type, prefix) {
+		switch (type.type.kind) {
+			case "object":
+				const items = Array.from(type.type.props.entries());
+				for (const [key, value] of items) this._flattenType(value, prefix ? `${prefix}.${key}` : key);
+				break;
+			case "array":
+				this._flattenType(type.type.of, prefix);
+				break;
+			case "intersection":
+			case "tuple":
+			case "union": for (const item of type.type.items) this._flattenType(item, prefix);
+			default:
+				this._flatMap?.set(prefix || "", type);
+				break;
+		}
+		if (prefix) this._prepareIndexesForField(prefix, type.metadata);
+	}
+	_prepareIndexesForCollection() {
+		const typeMeta = this.type.metadata;
+		const dynamicText = typeMeta.get("mongo.search.dynamic");
+		if (dynamicText) this._setSearchIndex("dynamic_text", "_", {
+			mappings: { dynamic: true },
+			analyzer: dynamicText.analyzer,
+			text: { fuzzy: { maxEdits: dynamicText.fuzzy || 0 } }
+		});
+		for (const textSearch of typeMeta.get("mongo.search.static") || []) this._setSearchIndex("search_text", textSearch.indexName, {
+			mappings: { fields: {} },
+			analyzer: textSearch.analyzer,
+			text: { fuzzy: { maxEdits: textSearch.fuzzy || 0 } }
+		});
+	}
+	_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
+			});
+		}
+	}
+	_prepareIndexesForField(fieldName, metadata) {
+		for (const index of metadata.get("mongo.index.plain") || []) this._addIndexField("plain", index === true ? fieldName : index, fieldName);
+		for (const index of metadata.get("mongo.index.unique") || []) this._addIndexField("unique", index === true ? fieldName : index, fieldName);
+		const textWeight = metadata.get("mongo.index.text");
+		if (textWeight) this._addIndexField("text", "", fieldName, textWeight === true ? 1 : textWeight);
+		for (const index of metadata.get("mongo.search.text") || []) this._addFieldToSearchIndex("search_text", index.indexName, fieldName, index.analyzer);
+		const vectorIndex = metadata.get("mongo.search.vector");
+		if (vectorIndex) this._setSearchIndex("vector", vectorIndex.indexName || fieldName, { fields: [{
+			type: "vector",
+			path: fieldName,
+			similarity: vectorIndex.similarity || "dotProduct",
+			numDimensions: vectorIndex.dimensions
+		}] });
+		for (const index of metadata.get("mongo.search.filter") || []) this._vectorFilters.set(indexKey("vector", index.indexName), fieldName);
+	}
+	_flatten() {
+		if (!this._flatMap) {
+			this._flatMap = new Map();
+			this._prepareIndexesForCollection();
+			this._flattenType(this.type);
+			this._finalizeIndexesForCollection();
+		}
+	}
+	get flatMap() {
+		this._flatten();
+		return this._flatMap;
+	}
+	async syncIndexes() {
+		await this.ensureExists();
+		const existingIndexes = await this.collection.listIndexes().toArray();
+		const indexesToCreate = new Map(this.indexes);
+		for (const remote of existingIndexes) {
+			if (!remote.name.startsWith(INDEX_PREFIX)) continue;
+			if (indexesToCreate.has(remote.name)) {
+				const local = indexesToCreate.get(remote.name);
+				switch (local.type) {
+					case "plain":
+					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);
+						}
+						break;
+					default:
+				}
+			} else {
+				this.logger.debug(`dropping index "${remote.name}"`);
+				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":
+						let 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) {
+			case "plain":
+				this.logger.debug(`creating index "${key}"`);
+				await this.collection.createIndex(value.fields, { name: key });
+				break;
+			case "unique":
+				this.logger.debug(`creating index "${key}"`);
+				await this.collection.createIndex(value.fields, {
+					name: key,
+					unique: true
+				});
+				break;
+			case "text":
+				this.logger.debug(`creating index "${key}"`);
+				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({
+						name: key,
+						type: value.type === "vector" ? "vectorSearch" : "search",
+						definition: value.definition
+					});
+				}
+				break;
+			default:
+		}
+	}
+	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, "_indexes", void 0);
+		_define_property$1(this, "_vectorFilters", void 0);
+		_define_property$1(this, "_flatMap", void 0);
+		this.asMongo = asMongo;
+		this._type = _type;
+		this.logger = logger;
+		this._indexes = new Map();
+		this._vectorFilters = new Map();
+		if (!isAnnotatedType(_type)) throw new Error("Atscript Annotated Type expected");
+		const name = _type.metadata.get("mongo.collection");
+		if (!name) throw new Error("@mongo.collection 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);
+	}
+};
+/**
+* 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;
+}
+/**
+* Search Index fields matching
+*/ 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;
+	});
+}
+/**
+* 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]);
+}
+
+//#endregion
+//#region packages/mongo/src/lib/as-mongo.ts
+function _define_property(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+else obj[key] = value;
+	return obj;
+}
+var AsMongo = class {
+	get db() {
+		return this.client.db();
+	}
+	getCollectionsList() {
+		if (!this.collectionsList) this.collectionsList = this.db.listCollections().toArray().then((c) => new Set(c.map((c$1) => c$1.name)));
+		return this.collectionsList;
+	}
+	async collectionExists(name) {
+		const list = await this.getCollectionsList();
+		return list.has(name);
+	}
+	getCollection(type, logger) {
+		return new AsCollection(this, type, logger || this.logger);
+	}
+	constructor(client, logger = NoopLogger) {
+		_define_property(this, "logger", void 0);
+		_define_property(this, "client", void 0);
+		_define_property(this, "collectionsList", void 0);
+		this.logger = logger;
+		if (typeof client === "string") this.client = new MongoClient(client);
+else this.client = client;
+	}
+};
+
+//#endregion
+export { AsCollection, AsMongo, MongoPlugin };

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@atscript/mongo",
+  "version": "0.0.1",
+  "description": "Mongodb plugin for atscript.",
+  "type": "module",
+  "main": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "cli.cjs"
+  ],
+  "keywords": [
+    "atscript",
+    "plugin",
+    "mongodb"
+  ],
+  "author": "Artem Maltsev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/moostjs/atscript.git",
+    "directory": "packages/mongo"
+  },
+  "bugs": {
+    "url": "https://github.com/moostjs/atscript/issues"
+  },
+  "homepage": "https://github.com/moostjs/atscript/tree/main/packages/mongo#readme",
+  "license": "ISC",
+  "dependencies": {
+    "mongodb": "^6.13.0",
+    "@atscript/core": "^0.0.1",
+    "@atscript/typescript": "^0.0.1"
+  },
+  "devDependencies": {
+    "vitest": "^3.0.0"
+  },
+  "scripts": {
+    "pub": "pnpm publish --access public",
+    "test": "vitest"
+  }
+}