momos 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Rhinobase
+
+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/README.md

@@ -0,0 +1,18 @@
+# 🥟 Momos
+
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/rhinobase/momos)
+[![npm version](https://img.shields.io/npm/v/momos.svg)](https://npmjs.org/package/momos "View this project on NPM")
+[![npm downloads](https://img.shields.io/npm/dm/momos)](https://www.npmjs.com/package/momos)
+
+A lightweight, type-safe MongoDB ORM that uses your validation schema for type-safe queries, inserts, and updates. Validates documents before insert/update operations automatically.
+
+This lib supports all the validation libs which are [Standard Schema](https://standardschema.dev/) compliant (zod, valibot, arktype, etc.).
+
+For documentation visit [honohub.dev](https://honohub.dev/docs/momos).
+
+> [!Note]
+> This package is still in development and your feedback is highly appreciated. If you have any suggestions or issues, please let us know by creating an issue on GitHub.
+
+## Contributing
+
+Visit our [contributing docs](https://github.com/rhinobase/momos/blob/main/CONTRIBUTING.md).

package/dist/index.cjs

@@ -0,0 +1,375 @@
+'use strict';
+
+class TypedCursor {
+  constructor(cursor) {
+    this.cursor = cursor;
+  }
+  /**
+   * Get the underlying MongoDB cursor
+   */
+  get raw() {
+    return this.cursor;
+  }
+  /**
+   * Returns all documents as an array
+   */
+  async toArray() {
+    return this.cursor.toArray();
+  }
+  /**
+   * Iterate over documents with a callback
+   */
+  async forEach(callback) {
+    for await (const doc of this.cursor) {
+      await callback(doc);
+    }
+  }
+  /**
+   * Map documents to a new type
+   */
+  map(transform) {
+    return new TypedCursor(this.cursor.map(transform));
+  }
+  /**
+   * Check if there are more documents
+   */
+  async hasNext() {
+    return this.cursor.hasNext();
+  }
+  /**
+   * Get the next document
+   */
+  async next() {
+    return this.cursor.next();
+  }
+  /**
+   * Close the cursor
+   */
+  async close() {
+    await this.cursor.close();
+  }
+  /**
+   * Make the cursor iterable
+   */
+  [Symbol.asyncIterator]() {
+    return this.cursor[Symbol.asyncIterator]();
+  }
+}
+class TypedFindCursor extends TypedCursor {
+  /**
+   * Map documents to a new type
+   */
+  map(transform) {
+    return new TypedFindCursor(this.cursor.map(transform));
+  }
+  /**
+   * Limit the number of documents returned
+   */
+  limit(count) {
+    this.cursor.limit(count);
+    return this;
+  }
+  /**
+   * Skip a number of documents
+   */
+  skip(count) {
+    this.cursor.skip(count);
+    return this;
+  }
+  /**
+   * Sort the documents
+   */
+  sort(sort) {
+    this.cursor.sort(sort);
+    return this;
+  }
+  /**
+   * Project specific fields
+   */
+  project(projection) {
+    this.cursor.project(projection);
+    return this;
+  }
+  /**
+   * Set batch size for cursor
+   */
+  batchSize(size) {
+    this.cursor.batchSize(size);
+    return this;
+  }
+}
+class TypedAggregationCursor extends TypedCursor {
+  /**
+   * Map documents to a new type
+   */
+  map(transform) {
+    return new TypedAggregationCursor(this.cursor.map(transform));
+  }
+}
+
+class ValidationError extends Error {
+  issues;
+  constructor(issues) {
+    const message = issues.map((i) => i.message).join(", ");
+    super(`Validation failed: ${message}`);
+    this.name = "ValidationError";
+    this.issues = issues;
+  }
+}
+
+async function validate(schema, data) {
+  const result = await schema["~standard"].validate(data);
+  if (result.issues) {
+    throw new ValidationError(result.issues);
+  }
+  return result.value;
+}
+async function validateMany(schema, data) {
+  return Promise.all(data.map((item) => validate(schema, item)));
+}
+async function isValid(schema, data) {
+  const result = await schema["~standard"].validate(data);
+  return !result.issues;
+}
+
+class TypedCollection {
+  collection;
+  schema;
+  shouldValidate;
+  constructor(collection, schema, options = {}) {
+    this.collection = collection;
+    this.schema = schema;
+    this.shouldValidate = options.validate !== false;
+  }
+  /**
+   * Get the underlying MongoDB collection
+   */
+  get raw() {
+    return this.collection;
+  }
+  /**
+   * Get the collection name
+   */
+  get collectionName() {
+    return this.collection.collectionName;
+  }
+  // ============================================
+  // INSERT OPERATIONS
+  // ============================================
+  /**
+   * Insert a single document
+   * Validates the document before insertion if validation is enabled
+   */
+  async insertOne(doc, options) {
+    const validated = this.shouldValidate ? await validate(this.schema, doc) : doc;
+    return this.collection.insertOne(validated, options);
+  }
+  /**
+   * Insert multiple documents
+   * Validates all documents before insertion if validation is enabled
+   */
+  async insertMany(docs, options) {
+    const validated = this.shouldValidate ? await validateMany(this.schema, docs) : docs;
+    return this.collection.insertMany(validated, options);
+  }
+  // ============================================
+  // FIND OPERATIONS
+  // ============================================
+  /**
+   * Find documents matching the filter
+   * Returns a typed cursor for further operations
+   */
+  find(filter = {}, options) {
+    const cursor = this.collection.find(filter, options);
+    return new TypedFindCursor(cursor);
+  }
+  /**
+   * Find a single document matching the filter
+   */
+  async findOne(filter = {}, options) {
+    const result = await this.collection.findOne(filter, options);
+    return result;
+  }
+  /**
+   * Find a document by its _id
+   */
+  async findById(id, options) {
+    return this.findOne({ _id: id }, options);
+  }
+  // ============================================
+  // UPDATE OPERATIONS
+  // ============================================
+  /**
+   * Update a single document
+   */
+  async updateOne(filter, update, options) {
+    return this.collection.updateOne(
+      filter,
+      update,
+      options
+    );
+  }
+  /**
+   * Update multiple documents
+   */
+  async updateMany(filter, update, options) {
+    return this.collection.updateMany(
+      filter,
+      update,
+      options
+    );
+  }
+  /**
+   * Replace a single document
+   * Validates the replacement document if validation is enabled
+   */
+  async replaceOne(filter, replacement, options) {
+    const validated = this.shouldValidate ? await validate(this.schema, replacement) : replacement;
+    return this.collection.replaceOne(
+      filter,
+      validated,
+      options
+    );
+  }
+  /**
+   * Find a document and update it atomically
+   */
+  async findOneAndUpdate(filter, update, options = {}) {
+    const result = await this.collection.findOneAndUpdate(
+      filter,
+      update,
+      options
+    );
+    return result;
+  }
+  /**
+   * Find a document and replace it atomically
+   * Validates the replacement document if validation is enabled
+   */
+  async findOneAndReplace(filter, replacement, options = {}) {
+    const validated = this.shouldValidate ? await validate(this.schema, replacement) : replacement;
+    const result = await this.collection.findOneAndReplace(
+      filter,
+      validated,
+      options
+    );
+    return result;
+  }
+  // ============================================
+  // DELETE OPERATIONS
+  // ============================================
+  /**
+   * Delete a single document
+   */
+  async deleteOne(filter, options) {
+    return this.collection.deleteOne(filter, options);
+  }
+  /**
+   * Delete multiple documents
+   */
+  async deleteMany(filter, options) {
+    return this.collection.deleteMany(filter, options);
+  }
+  /**
+   * Find a document and delete it atomically
+   */
+  async findOneAndDelete(filter, options = {}) {
+    const result = await this.collection.findOneAndDelete(
+      filter,
+      options
+    );
+    return result;
+  }
+  // ============================================
+  // COUNT OPERATIONS
+  // ============================================
+  /**
+   * Count documents matching the filter
+   */
+  async countDocuments(filter = {}, options) {
+    return this.collection.countDocuments(filter, options);
+  }
+  /**
+   * Get an estimated count of documents (faster, uses metadata)
+   */
+  async estimatedDocumentCount(options) {
+    return this.collection.estimatedDocumentCount(options);
+  }
+  // ============================================
+  // AGGREGATION
+  // ============================================
+  /**
+   * Run an aggregation pipeline
+   */
+  aggregate(pipeline, options) {
+    const cursor = this.collection.aggregate(pipeline, options);
+    return new TypedAggregationCursor(cursor);
+  }
+  // ============================================
+  // INDEX OPERATIONS
+  // ============================================
+  /**
+   * Create an index
+   */
+  async createIndex(indexSpec, options) {
+    return this.collection.createIndex(indexSpec, options);
+  }
+  /**
+   * Create multiple indexes
+   */
+  async createIndexes(indexSpecs, options) {
+    return this.collection.createIndexes(indexSpecs, options);
+  }
+  /**
+   * Drop an index
+   */
+  async dropIndex(indexName, options) {
+    await this.collection.dropIndex(indexName, options);
+  }
+  /**
+   * List all indexes
+   */
+  async indexes() {
+    return this.collection.indexes();
+  }
+  // ============================================
+  // UTILITY OPERATIONS
+  // ============================================
+  /**
+   * Get distinct values for a field
+   */
+  async distinct(field, filter = {}) {
+    const result = await this.collection.distinct(
+      field,
+      filter
+    );
+    return result;
+  }
+  /**
+   * Check if a document exists
+   */
+  async exists(filter) {
+    const count = await this.countDocuments(filter, { limit: 1 });
+    return count > 0;
+  }
+  /**
+   * Drop the collection
+   */
+  async drop() {
+    await this.collection.drop();
+  }
+}
+function defineCollection(db, name, schema, options = {}) {
+  const collection = db.collection(name);
+  return new TypedCollection(collection, schema, options);
+}
+
+exports.TypedAggregationCursor = TypedAggregationCursor;
+exports.TypedCollection = TypedCollection;
+exports.TypedCursor = TypedCursor;
+exports.TypedFindCursor = TypedFindCursor;
+exports.ValidationError = ValidationError;
+exports.defineCollection = defineCollection;
+exports.isValid = isValid;
+exports.validate = validate;
+exports.validateMany = validateMany;