initial commit

Author: vkarpov15

.gitignore

@@ -134,3 +134,5 @@ dist
 .yarn/build-state.yml
 .yarn/install-state.gz
 .pnp.*
+
+test-results

.npmignore

@@ -0,0 +1 @@
+test

.npmrc

@@ -0,0 +1 @@
+package-lock=false

browser.js

@@ -0,0 +1,10 @@
+'use strict';
+
+require('mongoose/lib/driver').set(require('./driver'));
+
+const mongoose = require('mongoose/lib/mongoose');
+module.exports = mongoose;
+
+if (typeof window !== 'undefined') {
+  window.mongoose = mongoose;
+}

driver/index.js

@@ -0,0 +1,129 @@
+'use strict';
+
+const MongooseCollection = require('mongoose/lib/collection');
+const MongooseConnection = require('mongoose/lib/connection');
+
+class Collection extends MongooseCollection {
+  get collection() {
+    return this;
+  }
+
+  aggregate() {
+    throw new Error('Database operations not supported in @mongoosejs/browser');
+  }
+
+  bulkWrite() {
+    throw new Error('Database operations not supported in @mongoosejs/browser');
+  }
+
+  createIndex() {
+    throw new Error('Database operations not supported in @mongoosejs/browser');
+  }
+
+  countDocuments() {
+    throw new Error('Database operations not supported in @mongoosejs/browser');
+  }
+
+  deleteMany() {
+    throw new Error('Database operations not supported in @mongoosejs/browser');
+  }
+
+  deleteOne() {
+    throw new Error('Database operations not supported in @mongoosejs/browser');
+  }
+
+  distinct() {
+    throw new Error('Database operations not supported in @mongoosejs/browser');
+  }
+
+  dropIndex() {
+    throw new Error('Database operations not supported in @mongoosejs/browser');
+  }
+
+  estimatedDocumentCount() {
+    throw new Error('Database operations not supported in @mongoosejs/browser');
+  }
+
+  find() {
+    throw new Error('Database operations not supported in @mongoosejs/browser');
+  }
+
+  findOne() {
+    throw new Error('Database operations not supported in @mongoosejs/browser');
+  }
+
+  findOneAndDelete() {
+    throw new Error('Database operations not supported in @mongoosejs/browser');
+  }
+
+  findOneAndReplace() {
+    throw new Error('Database operations not supported in @mongoosejs/browser');
+  }
+
+  findOneAndUpdate() {
+    throw new Error('Database operations not supported in @mongoosejs/browser');
+  }
+
+  listIndexes() {
+    throw new Error('Database operations not supported in @mongoosejs/browser');
+  }
+
+  insertMany() {
+    throw new Error('Database operations not supported in @mongoosejs/browser');
+  }
+
+  insertOne() {
+    throw new Error('Database operations not supported in @mongoosejs/browser');
+  }
+
+  replaceOne() {
+    throw new Error('Database operations not supported in @mongoosejs/browser');
+  }
+
+  updateOne() {
+    throw new Error('Database operations not supported in @mongoosejs/browser');
+  }
+
+  updateMany() {
+    throw new Error('Database operations not supported in @mongoosejs/browser');
+  }
+};
+exports.Collection = Collection;
+
+exports.Connection = class Connection extends MongooseConnection {
+  collection(name, options) {
+    if (!(name in this.collections)) {
+      this.collections[name] = new Collection(name, this, options);
+    }
+    return super.collection(name, options);
+  }
+
+  createCollection(name, options) {
+    this.collection(name, options);
+  }
+
+  async dropCollection(name) {
+    delete this.collections[name];
+  }
+
+  openUri() {
+    throw new Error('Cannot call connect() in @mongoosejs/browser');
+  }
+
+  asPromise() {
+    return Promise.resolve(this);
+  }
+
+  doClose(_force, cb) {
+    if (cb) {
+      cb(null);
+    }
+    return this;
+  }
+
+  async dropDatabase() {
+    this.collections = {};
+  }
+};
+
+exports.BulkWriteResult = function() {};

index.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./src/driver');

package.json

@@ -0,0 +1,30 @@
+{
+  "package": "@mongoosejs/browser",
+  "version": "0.0.1",
+  "private": false,
+  "browser": "./dist/index.js",
+  "scripts": {
+    "build": "rm -rf ./dist/* && node scripts/build-browser.js",
+    "postinstall": "playwright install-deps && playwright install chromium",
+    "prepublish": "npm run build",
+    "test:browser": "playwright test ./test/browser.test.js",
+    "test:node": "mocha test/*.node.test.js"
+  },
+  "peerDependencies": {
+    "mongoose": "8.x"
+  },
+  "devDependencies": {
+    "@babel/core": "7.26.10",
+    "@babel/preset-env": "7.26.9",
+    "@playwright/test": "^1.52.0",
+    "assert-browserify": "2.0.0",
+    "babel-loader": "8.2.5",
+    "buffer": "^5.6.0",
+    "crypto-browserify": "3.12.1",
+    "mocha": "^10.2.0",
+    "mongoose": "git+https://github.com/Automattic/mongoose.git#9.0",
+    "playwright": "1.49.1",
+    "stream-browserify": "3.0.0",
+    "webpack": "5.98.0"
+  }
+}

scripts/build-browser.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const config = require('../webpack.config.js');
+const webpack = require('webpack');
+
+const compiler = webpack(config);
+
+console.log('Starting browser build...');
+compiler.run((err, stats) => {
+  if (err) {
+    console.err(stats.toString());
+    console.err('Browser build unsuccessful.');
+    process.exit(1);
+  }
+  console.log(stats.toString());
+  console.log('Browser build successful.');
+  process.exit(0);
+});

test/browser.node.test.js

@@ -0,0 +1,102 @@
+'use strict';
+
+/**
+ * Module dependencies.
+ */
+
+const assert = require('assert');
+const mongoose = require('../browser');
+const exec = require('child_process').exec;
+
+/**
+ * Test.
+ */
+describe('browser', function() {
+  it('require() works with no other require calls (gh-5842)', function(done) {
+    exec('node --eval "require(\'./browser\')"', done);
+  });
+
+  it('using schema (gh-7170)', function(done) {
+    exec('node --eval "const mongoose = require(\'./browser\'); new mongoose.Schema();"', done);
+  });
+
+  it('document works (gh-4987)', function() {
+    const schema = new mongoose.Schema({
+      name: { type: String, required: true },
+      quest: { type: String, match: /Holy Grail/i, required: true },
+      favoriteColor: { type: String, enum: ['Red', 'Blue'], required: true }
+    });
+
+    assert.doesNotThrow(function() {
+      new mongoose.Document({}, schema);
+    });
+  });
+
+  it('document validation with arrays (gh-6175)', async function() {
+    const Point = new mongoose.Schema({
+      latitude: {
+        type: Number,
+        required: true,
+        min: -90,
+        max: 90
+      },
+      longitude: {
+        type: Number,
+        required: true,
+        min: -180,
+        max: 180
+      }
+    });
+
+    const schema = new mongoose.Schema({
+      name: {
+        type: String,
+        required: true
+      },
+      vertices: {
+        type: [Point],
+        required: true
+      }
+    });
+
+    let test = new mongoose.Document({
+      name: 'Test Polygon',
+      vertices: [
+        {
+          latitude: -37.81902680201739,
+          longitude: 144.9821037054062
+        }
+      ]
+    }, schema);
+
+    // Should not throw
+    await test.validate();
+
+    test = new mongoose.Document({
+      name: 'Test Polygon',
+      vertices: [
+        {
+          latitude: -37.81902680201739
+        }
+      ]
+    }, schema);
+
+    const error = await test.validate().then(() => null, err => err);
+    assert.ok(error.errors['vertices.0.longitude']);
+  });
+
+  it('throws errors when using db operations', async function () {
+    const TestModel = mongoose.model('Test', mongoose.Schema({ name: String }));
+    const doc = new TestModel({ name: 'test' });
+    await assert.rejects(doc.save(), /Database operations not supported in @mongoosejs\/browser/);
+
+    await assert.rejects(TestModel.aggregate([{ $match: {} }]), /Database operations not supported in @mongoosejs\/browser/);
+    await assert.rejects(TestModel.create({ name: 'test' }), /Database operations not supported in @mongoosejs\/browser/);
+    await assert.rejects(TestModel.deleteMany({ name: 'test' }), /Database operations not supported in @mongoosejs\/browser/);
+    await assert.rejects(TestModel.deleteOne({ name: 'test' }), /Database operations not supported in @mongoosejs\/browser/);
+    await assert.rejects(TestModel.find({ name: 'test' }), /Database operations not supported in @mongoosejs\/browser/);
+    await assert.rejects(TestModel.findOne({ name: 'test' }), /Database operations not supported in @mongoosejs\/browser/);
+    await assert.rejects(TestModel.updateMany({ name: 'test' }, { name: 'test2' }), /Database operations not supported in @mongoosejs\/browser/);
+    await assert.rejects(TestModel.updateOne({ name: 'test' }, { name: 'test2' }), /Database operations not supported in @mongoosejs\/browser/);
+  });
+});

test/browser.test.js

@@ -0,0 +1,83 @@
+'use strict';
+
+const assert = require('assert');
+const { test } = require('@playwright/test');
+
+test('can create new schema without errors', async ({ page }) => {
+  await page.addScriptTag({ path: './dist/mongoose.umd.js' });
+
+  const result = await page.evaluate(() => {
+    const schema = new mongoose.Schema({ name: String });
+    const TestModel = mongoose.model('Test', schema);
+    const doc = new TestModel({ name: 'John' });
+    return !doc.validateSync();
+  });
+
+  assert.strictEqual(result, true);
+});
+
+test('reports validation errors', async ({ page }) => {
+  await page.addScriptTag({ path: './dist/mongoose.umd.js' });
+
+  const result = await page.evaluate(async () => {
+    try {
+      const schema = new mongoose.Schema({ name: { type: String, required: true } });
+      const TestModel = mongoose.model('Test', schema);
+      const doc = new TestModel();
+      await doc.validate();
+    } catch (error) {
+      return error.message;
+    }
+  });
+
+  assert.strictEqual(result, 'Validation failed: name: Path `name` is required.');
+});
+
+test('TestModel.findOne() throws an expected error', async ({ page }) => {
+  await page.addScriptTag({ path: './dist/mongoose.umd.js' });
+
+  const result = await page.evaluate(async () => {
+    try {
+      const schema = new mongoose.Schema({ name: String });
+      const TestModel = mongoose.model('Test', schema);
+      await TestModel.findOne();
+      return false;
+    } catch (error) {
+      return error.message;
+    }
+  });
+
+  assert.strictEqual(result, 'Database operations not supported in @mongoosejs/browser');
+});
+
+test('TestModel.find() throws an expected error', async ({ page }) => {
+  await page.addScriptTag({ path: './dist/mongoose.umd.js' });
+
+  const result = await page.evaluate(async () => {
+    try {
+      const schema = new mongoose.Schema({ name: String });
+      const TestModel = mongoose.model('Test', schema);
+      await TestModel.find();
+      return false;
+    } catch (error) {
+      return error.message;
+    }
+  });
+
+  assert.strictEqual(result, 'Database operations not supported in @mongoosejs/browser');
+});
+
+test('mongoose.connect() throws an expected error', async ({ page }) => {
+  await page.addScriptTag({ path: './dist/mongoose.umd.js' });
+
+  const result = await page.evaluate(async () => {
+    try {
+      await mongoose.connect('mongodb://localhost:27017/test');
+      return false;
+    } catch (error) {
+      return error.message;
+    }
+  });
+
+  assert.strictEqual(result, 'Cannot call connect() in @mongoosejs/browser');
+});