momos 0.0.1

package/dist/index.js

@@ -0,0 +1,365 @@
+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);
+}
+
+export { TypedAggregationCursor, TypedCollection, TypedCursor, TypedFindCursor, ValidationError, defineCollection, isValid, validate, validateMany };

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "momos",
+  "description": "MongoDB ORM",
+  "version": "0.0.1",
+  "type": "module",
+  "license": "MIT",
+  "keywords": [
+    "mongodb",
+    "orm"
+  ],
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    "import": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "require": {
+      "types": "./dist/index.d.cts",
+      "default": "./dist/index.cjs"
+    }
+  },
+  "homepage": "https://honohub.dev/docs/momos",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rhinobase/momos.git"
+  },
+  "bugs": {
+    "url": "https://github.com/rhinobase/momos/issues"
+  },
+  "peerDependencies": {
+    "@standard-schema/spec": "^1.1.0",
+    "mongodb": "^7.0.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.10",
+    "husky": "^9.1.7",
+    "is-ci": "^4.1.0",
+    "nano-staged": "^0.9.0",
+    "pkgroll": "^2.21.4",
+    "typescript": "~5.9.3",
+    "vitest": "^4.0.16",
+    "zod": "^4.2.1"
+  },
+  "scripts": {
+    "build": "pkgroll --clean-dist",
+    "test": "vitest",
+    "format": "biome check --write ."
+  }
+}